[
{
"path": ".clang-format",
"content": "Language: Cpp\nBasedOnStyle: GNU\nSortIncludes: false\nAllowShortIfStatementsOnASingleLine: false\nBreakBeforeBraces: Linux\nTabWidth: 4\nIndentWidth: 4\nColumnLimit: 89\nSpaceBeforeParens:\n ControlStatements\nSpacesInCStyleCastParentheses: false\nSpaceAfterCStyleCast: true\nIndentCaseLabels: true\nAlignAfterOpenBracket: DontAlign\nBinPackArguments: true\nBinPackParameters: true\nAlwaysBreakAfterReturnType: AllDefinitions\n\nStatementMacros: [\"PyObject_HEAD\", \"Py_BEGIN_ALLOW_THREADS\", \"Py_END_ALLOW_THREADS\"]\nAlignConsecutiveMacros: true\n"
},
{
"path": ".github/PULL_REQUEST_TEMPLATE.md",
"content": "## Description\n\nThanks for contributing to tskit! :heart:\nA guide to the PR process is [here](https://tskit.dev/tskit/docs/stable/development.html#git-workflow)\nPlease replace this text with a summary of the change and which issue is fixed, if any. Please also include relevant motivation and context.\n\nFixes #(issue) <- Putting the issue number here will auto-close the issue when this PR is merged \n\n# PR Checklist:\n\n- [ ] Tests that fully cover new/changed functionality.\n- [ ] Documentation including tutorial content if appropriate.\n- [ ] Changelogs, if there are API changes.\n"
},
{
"path": ".github/workflows/docs.yml",
"content": "name: Build Docs\non:\n pull_request:\n merge_group:\n push:\n branches: [main]\n tags:\n - '*'\n\nenv:\n FORCE_COLOR: 1\n\njobs:\n Docs:\n uses: tskit-dev/.github/.github/workflows/docs.yml@v15\n with:\n pyproject-directory: python\n additional-apt-packages: doxygen\n pre-build-command: cd docs/doxygen && doxygen\n"
},
{
"path": ".github/workflows/lint.yml",
"content": "name: Lint\n\non:\n pull_request:\n merge_group:\n\njobs:\n Lint:\n uses: tskit-dev/.github/.github/workflows/lint.yml@v15\n with:\n pyproject-directory: python\n"
},
{
"path": ".github/workflows/release-c.yml",
"content": "name: Publish C API release\n\non:\n push:\n branches: [main, test]\n tags: ['*']\n\nenv:\n FORCE_COLOR: 1\n\njobs:\n build:\n runs-on: ubuntu-24.04\n steps:\n - name: Checkout\n uses: actions/checkout@v6.0.2\n - name: Install uv\n uses: astral-sh/setup-uv@v6\n with:\n version: \"0.10.0\"\n - name: Install system deps\n run: |\n sudo apt-get update\n sudo apt-get install -y ninja-build libcunit1-dev\n - name: Install meson\n run: uv tool install meson==1.10.1\n - name: Build tarball\n run: |\n git rm -rf c/tests/meson-subproject\n git config --global user.email \"CI@CI.com\"\n git config --global user.name \"Mr Robot\"\n git add -A\n git commit -m \"dummy commit to make meson not add in the symlinked directory\"\n meson c build-gcc\n meson dist -C build-gcc\n - name: C Release\n uses: softprops/action-gh-release@v2.5.0\n if: startsWith(github.ref, 'refs/tags/') && contains(github.event.ref, 'C_')\n with:\n draft: True\n files: build-gcc/meson-dist/*\n"
},
{
"path": ".github/workflows/tests.yml",
"content": "name: Tests\n\non:\n pull_request:\n merge_group:\n push:\n branches: [main, test]\n\nenv:\n FORCE_COLOR: 1\n\njobs:\n\n packaging:\n name: Python packaging\n uses: tskit-dev/.github/.github/workflows/python-packaging.yml@v15\n with:\n pyproject-directory: python\n cli-test-cmd: tskit --help\n\n test-c:\n name: C tests\n uses: tskit-dev/.github/.github/workflows/c-tests.yml@v15\n with:\n library-directory: c\n secrets: inherit\n\n test-python-c:\n name: Python-C tests\n uses: tskit-dev/.github/.github/workflows/python-c-tests.yml@v15\n with:\n tests: python/tests/test_python_c.py python/tests/test_dict_encoding.py\n pyproject-directory: python\n secrets: inherit\n\n\n test:\n name: Python\n uses: tskit-dev/.github/.github/workflows/python-tests.yml@v15\n with:\n os: ${{ matrix.os }}\n python-version: ${{ matrix.python }}\n pyproject-directory: python\n coverage-directory: python/tskit\n secrets: inherit\n strategy:\n matrix:\n python: [ 3.11, 3.13 ]\n os: [ macos-latest, ubuntu-24.04, windows-latest ]\n\n\n msys2:\n runs-on: windows-latest\n strategy:\n matrix:\n include:\n - { sys: mingw32, env: i686 }\n - { sys: mingw64, env: x86_64 }\n name: Windows (${{ matrix.sys }}, ${{ matrix.env }})\n defaults:\n run:\n shell: msys2 {0}\n steps:\n - name: Cancel Previous Runs\n uses: styfle/cancel-workflow-action@0.13.0\n with:\n access_token: ${{ github.token }}\n\n - name: 'Checkout'\n uses: actions/checkout@v6.0.2\n\n - name: Setup MSYS2 ${{matrix.sys}}\n uses: msys2/setup-msys2@v2.27.0\n with:\n msystem: ${{matrix.sys}}\n update: true\n install: >-\n git\n mingw-w64-${{matrix.env}}-toolchain\n mingw-w64-${{matrix.env}}-ninja\n mingw-w64-${{matrix.env}}-meson\n mingw-w64-${{matrix.env}}-cunit\n\n - name: Build\n working-directory: c\n run: |\n meson build -Dbuild_examples=false\n ninja -C build\n\n - name: Run tests\n working-directory: c\n run: |\n ninja -C build test\n\n bespoke-python-test:\n name: Bespoke Python tests\n runs-on: ubuntu-24.04\n\n steps:\n - name: Cancel Previous Runs\n uses: styfle/cancel-workflow-action@0.13.0\n with:\n access_token: ${{ github.token }}\n\n - name: Checkout\n uses: actions/checkout@v6.0.2\n with:\n submodules: true\n\n - name: Install uv and set the python version\n uses: astral-sh/setup-uv@v6\n with:\n python-version: 3.11\n version: \"0.10.0\"\n\n - name: Install Python dependencies\n working-directory: python\n run: uv sync --locked --group test --no-default-groups\n\n - name: Minidom test\n working-directory: python\n # Importing either IPython or pytest causes import of xml.dom.minidom\n # So to actually test that tskit imports it, we need a minimal test\n run: |\n uv run --locked --group test --no-default-groups \\\n python -c \"import tskit;tskit.Tree.generate_star(5).tree_sequence.draw_svg(path='test.svg')\"\n\n - name: Run JIT code coverage\n run: |\n NUMBA_DISABLE_JIT=1 uv run --locked --project=python --no-default-groups\\\n pytest --cov=python/tskit --cov-report=xml --cov-branch \\\n python/tests/test_jit.py\n\n - name: Upload coverage to Codecov\n uses: codecov/codecov-action@v5.5.2\n with:\n token: ${{ secrets.CODECOV_TOKEN }}\n fail_ci_if_error: true\n files: coverage.xml\n disable_search: true\n verbose: true\n flags: python-tests-no-jit\n\n - name: Build example LWT interface code and test\n working-directory: python/lwt_interface/\n run: |\n make allchecks\n uv run --project=../ --group=test pytest -vs\n\n - name: Build cython example LWT interface code and run\n working-directory: python/lwt_interface/cython_example\n run: make\n\n\n bespoke-c-test:\n name: Bespoke C tests\n runs-on: ubuntu-24.04\n\n steps:\n - name: Cancel Previous Runs\n uses: styfle/cancel-workflow-action@0.13.0\n with:\n access_token: ${{ github.token }}\n\n - name: Checkout\n uses: actions/checkout@v6.0.2\n with:\n submodules: true\n\n - name: Install system deps\n run: |\n sudo apt-get update\n sudo apt-get install -y libcunit1-dev ninja-build clang\n\n - name: Install uv\n uses: astral-sh/setup-uv@v6\n with:\n version: \"0.10.0\"\n\n - name: Install uv deps\n run: |\n uv tool install meson==1.10.1\n\n - name: Configure code\n run: CFLAGS=-D_TSK_BIG_TABLES CPPFLAGS=-D_TSK_BIG_TABLES meson setup build-bt c/\n\n - name: Compile\n run: ninja -C build-bt\n\n - name: Run tests\n run: ninja -C build-bt test\n\n\n - name: Test building with meson subproject\n run: |\n meson build-subproject c/tests/meson-subproject\n ninja -C build-subproject\n ./build-subproject/example\n\n - name: Install shared library and hand-compile program.\n run: |\n meson build-install c --prefix=/usr\n sudo ninja -C build-install install\n clang c/examples/api_structure.c -I c/subprojects/kastore -o api_structure -ltskit\n ./api_structure\n\n - name: Run example make file\n run: |\n make -C c/examples\n\n"
},
{
"path": ".github/workflows/wheels.yml",
"content": "name: Publish Python release\n\non:\n push:\n branches: [test-publish]\n release:\n types: [published]\n\njobs:\n build-wheels:\n if: \"!startsWith(github.ref, 'refs/tags/C_')\"\n uses: tskit-dev/.github/.github/workflows/build-wheels.yml@v15\n with:\n pyproject-directory: python\n\n publish:\n runs-on: ubuntu-24.04\n environment: release\n needs: [ 'build-wheels' ]\n permissions:\n id-token: write\n steps:\n - name: Download artifacts\n uses: actions/download-artifact@v7.0.0\n with:\n pattern: build-*\n path: dist\n merge-multiple: true\n\n - name: Show artifacts\n run: ls -lah dist\n\n - name: Publish distribution to Test PyPI\n if: github.event_name == 'push' && github.ref_name == 'test-publish'\n uses: pypa/gh-action-pypi-publish@v1.13.0\n with:\n repository-url: https://test.pypi.org/legacy/\n verbose: true\n\n - name: Publish distribution to Production PyPI\n if: github.event_name == 'release'\n uses: pypa/gh-action-pypi-publish@v1.13.0\n"
},
{
"path": ".gitignore",
"content": "build-gcc\n.DS_Store\npython/benchmark/*.trees\npython/benchmark/*.json\npython/benchmark/*.html\n.venv\n.env\n.vscode\nenv\n"
},
{
"path": "CONTRIBUTING.md",
"content": "# Contributing\n\nTskit is a free and open-source project that welcomes contributions from everyone.\nThe [Developer documentation](https://tskit.dev/tskit/docs/latest/development.html)\nwill help you get started. \n\nWe have an active slack group where tskit and associated projects are discussed.\nIf you wish to join email [admin@tskit.dev](mailto:admin@tskit.dev).\n\nWe ask all users to follow our [code of conduct](https://github.com/tskit-dev/.github/blob/main/CODE_OF_CONDUCT.md)\nwhen interacting with the project.\n"
},
{
"path": "LICENSE",
"content": "MIT License\n\nCopyright (c) 2018-2019 Tskit Developers\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
},
{
"path": "README.md",
"content": "# tskit ![](\"https://github.com/tskit-dev/administrative/blob/main/tskit_logo.svg\")
\n\n[](https://github.com/tskit-dev/tskit/blob/main/LICENSE)\n[](https://github.com/tskit-dev/tskit/graphs/contributors)\n[](https://github.com/tskit-dev/tskit/commits/main)\n[](https://codecov.io/gh/tskit-dev/tskit)\n\n\n[Documentation (stable)](https://tskit.dev/tskit/docs/stable/) • [Documentation (latest)](https://tskit.dev/tskit/docs/latest/)\n\n[](https://github.com/tskit-dev/tskit/actions/workflows/docs.yml)[](https://github.com/tskit-dev/tskit/actions/workflows/tests.yml)\n\n\nThe succinct tree sequence (`tskit`) format is an efficient way of representing\nthe genetic history - sometimes known as an\n[Ancestral Recombination Graph or ARG](https://doi.org/10.1093/genetics/iyae100) -\nof a set of related DNA sequences. `Tskit` is used\nby a number of software libraries and programs (such as\n[msprime](https://github.com/tskit-dev/msprime),\n[SLiM](https://github.com/MesserLab/SLiM),\n[fwdpp](http://molpopgen.github.io/fwdpp/), and\n[tsinfer](https://tskit.dev/tsinfer/docs/stable/)) that either simulate or infer\nthe evolutionary ancestry of genetic sequences.\n\nThe `tskit` library provides the underlying functionality used to load, examine, and\nmanipulate ARGs in the tree sequence format, including efficient access to the\nsequence of correlated trees along a genome and general methods to calculate\ngenetic statistics. `Tskit` often forms part of an installation of other\nsoftware packages such as those listed above. Please see the\n[documentation](https://tskit.dev/tskit/docs/stable/) for further details, which\nincludes\n[installation instructions](https://tskit.dev/tskit/docs/stable/installation.html).\n\nTo get started with tskit, tutorials and other content are at http://tskit.dev. For help\nand support from the community you can use\n[discussions](https://github.com/tskit-dev/tskit/discussions) here on github, or raise an\nissue for a specific bug or feature request.\n\nWe warmly welcome contributions from the community. Raise an issue if you have an\nidea you'd like to work on, or submit a PR for comments and help.\n\nThe base `tskit` library provides both a [Python](https://tskit.dev/tskit/docs/stable/python-api.html)\nand [C](https://tskit.dev/tskit/docs/stable/c-api.html) API. A Rust API is provided in the\n[tskit-rust](https://github.com/tskit-dev/tskit-rust) repository.\n\n\n#### Python API\n[](https://pypi.org/project/tskit/)\n[](https://pypi.org/project/tskit/)\n[](https://pypi.org/project/tskit/)\n[](https://github.com/psf/black)\n\n\nMost users of `tskit` will use the python API as it provides a convenient, high-level API\nto access, analyse and create tree sequences. Full documentation is\n[here](https://tskit.dev/tskit/docs/stable/python-api.html). \n\n#### C API\n[](https://en.wikipedia.org/wiki/C99)\n\n\nThe `tskit` C API provides comprehensive, low-level methods for manipulating and\nprocessing tree-sequences. Written to the C99 standard and fully thread-safe, it can be\nused with either C or C++. Full documentation is\n[here](https://tskit.dev/tskit/docs/stable/c-api.html).\n\n## Installation\n\n```bash\npython -m pip install tskit\n# or\nconda install -c conda-forge tskit\n```\n"
},
{
"path": "c/.gitignore",
"content": "build\n.*.swp\n.*.swo\n"
},
{
"path": "c/CHANGELOG.rst",
"content": "--------------------\n[1.3.2] - 2026-XX-XX\n--------------------\n\nIn development\n\n- Add ``tsk_json_struct_metadata_get_blob`` function\n (:user:`benjeffery`, :pr:`3306`)\n\n--------------------\n[1.3.1] - 2026-03-06\n--------------------\n\nMaintenance release.\n\n- Update to kastore 2.1.2\n- Fix doc typo for file uuid (:pr:`3399`)\n- Migrate linting to clang-format 21.1.8 (:pr:`3389`)\n- Support compile time setting of debug stream (:pr:`3364`)\n\n--------------------\n[1.3.0] - 2025-11-27\n--------------------\n\n**Breaking changes**\n\n- ``trees.c`` now depends on ``genotypes.c`` (via ``tskit/genotypes.h``) and must\n be built and linked together with it.\n (:user:`benjeffery`, :pr:`3324`)\n\n\n**Features**\n\n- ``tsk_variant_init`` and associated variant decoding methods now\n fully support ``TSK_ISOLATED_NOT_MISSING`` not being set for internal nodes.\n (:user:`benjeffery`, :pr:`3313`)\n\n- Add ``tsk_treeseq_decode_alignments`` to decode full-length reference-based\n sequence alignments for specified nodes over a genomic interval, respecting\n ``TSK_ISOLATED_NOT_MISSING`` semantics.\n (:user:`benjeffery`, :pr:`3324`, :issue:`3319`)\n\n\n--------------------\n[1.2.0] - 2025-09-24\n--------------------\n\n**Breaking changes**\n\n- Remove ``tsk_diff_iter_t`` and associated functions.\n (:user:`benjeffery`, :pr:`3221`, :issue:`2797`).\n\n- ``tsk_treeseq_init`` now requires that mutation parents in the table collection\n are correct and consistent with the topology of the tree at each mutation site.\n Returns ``TSK_ERR_BAD_MUTATION_PARENT`` if this is not the case, or\n ``TSK_ERR_MUTATION_PARENT_AFTER_CHILD`` if the mutations are not in an order\n compatible with the correct mutation parent.\n (:user:`benjeffery`, :issue:`2729`, :issue:`2732`, :pr:`3212`).\n\n**Features**\n\n- Add ``TSK_TS_INIT_COMPUTE_MUTATION_PARENTS`` to ``tsk_treeseq_init``\n to compute mutation parents from the tree sequence topology.\n Note that the mutations must be in the correct order.\n (:user:`benjeffery`, :issue:`2757`, :pr:`3212`).\n\n- Add ``TSK_CHECK_MUTATION_PARENTS`` option to ``tsk_table_collection_check_integrity``\n to check that mutation parents are consistent with the tree sequence topology.\n This option implies ``TSK_CHECK_TREES``.\n (:user:`benjeffery`, :issue:`2729`, :issue:`2732`, :pr:`3212`).\n\n- Add the ``TSK_NO_CHECK_INTEGRITY`` option to ``tsk_table_collection_compute_mutation_parents``\n to skip the integrity checks that are normally run when computing mutation parents.\n This is useful for speeding up the computation of mutation parents when the\n tree sequence is certainly known to be valid.\n (:user:`benjeffery`, :pr:`3212`).\n\n- Mutations returned by ``tsk_treeseq_get_mutation`` now include pre-computed\n ``inherited_state`` and ``inherited_state_length`` fields. The inherited state\n is computed during tree sequence initialization and represents the state that\n existed at the site before each mutation occurred (either the ancestral state\n if the mutation is the root mutation or the derived state of the parent mutation).\n Note that this breaks ABI compatibility due to the addition of these fields\n to the ``tsk_mutation_t`` struct.\n (:user:`benjeffery`, :pr:`3277`, :issue:`2631`).\n\n\n\n--------------------\n[1.1.4] - 2025-03-31\n--------------------\n\n**Changes**\n\n- Added the TSK_TRACE_ERRORS macro to enable tracing of errors in the C library.\n This is useful for debugging as errors will print to stderr when set.\n (:user:`jeromekelleher`, :pr:`3095`).\n\n--------------------\n[1.1.3] - 2024-10-16\n--------------------\n\n**Features**\n\n- Add the `tsk_treeseq_extend_haplotypes` method that can compress a tree sequence\n by extending edges into adjacent trees and thus creating unary nodes in those\n trees (:user:`petrelharp`, :user:`hfr1tze`, :user:`avabamf`, :pr:`2651`, :pr:`2938`).\n\n--------------------\n[1.1.2] - 2023-05-17\n--------------------\n\n**Performance improvements**\n\n- tsk_tree_seek is now much faster at seeking to arbitrary points along\n the sequence from the null tree (:user:`molpopgen`, :pr:`2661`).\n\n**Features**\n\n- The struct ``tsk_treeseq_t`` now has the variables ``min_time`` and ``max_time``,\n which are the minimum and maximum among the node times and mutation times,\n respectively. ``min_time`` and ``max_time`` can be accessed using the functions\n ``tsk_treeseq_get_min_time`` and ``tsk_treeseq_get_max_time``, respectively.\n (:user:`szhan`, :pr:`2612`, :issue:`2271`)\n\n- Add the `TSK_SIMPLIFY_NO_FILTER_NODES` option to simplify to allow unreferenced\n nodes be kept in the output (:user:`jeromekelleher`, :user:`hyanwong`,\n :issue:`2606`, :pr:`2619`).\n\n- Add the `TSK_SIMPLIFY_NO_UPDATE_SAMPLE_FLAGS` option to simplify which ensures\n no node sample flags are changed to allow calling code to manage sample status.\n (:user:`jeromekelleher`, :issue:`2662`, :pr:`2663`).\n\n- Guarantee that unfiltered tables are not written to unnecessarily\n during simplify (:user:`jeromekelleher`, :pr:`2619`).\n\n- Add `x_table_keep_rows` methods to provide efficient in-place table subsetting\n (:user:`jeromekelleher`, :pr:`2700`).\n\n- Add `tsk_tree_seek_index` function\n\n--------------------\n[1.1.1] - 2022-07-29\n--------------------\n\n**Bug fixes**\n\n- Fix segfault in tsk_variant_restricted_copy in tree sequences with large\n numbers of alleles or very long alleles\n (:user:`jeromekelleher`, :pr:`2437`, :issue:`2429`).\n\n--------------------\n[1.1.0] - 2022-07-14\n--------------------\n\n**Features**\n\n- Add ``num_children`` to ``tsk_tree_t`` an array which contains counts of the number of child\n nodes of each node in the tree. (:user:`GertjanBisschop`, :issue:`2274`, :pr:`2316`)\n\n- Add ``edge`` to ``tsk_tree_t`` an array which contains the ``edge_id`` of the edge encoding\n the relationship between the child node and its parent for each (child) node in the tree.\n (:user:`GertjanBisschop`, :issue:`2304`, :pr:`2340`)\n\n\n**Changes**\n\n- Reduce the maximum number of rows in a table by 1. This removes edge cases so that a ``tsk_id_t`` can be\n used to count the number of rows. (:user:`benjeffery`, :issue:`2336`, :pr:`2337`)\n\n- Samples are now copied by ``tsk_variant_restricted_copy``. (:user:`benjeffery`, :issue:`2400`, :pr:`2401`)\n\n\n--------------------\n[1.0.0] - 2022-05-24\n--------------------\n\nThis major release marks the point at which the documented API becomes stable and supported.\n\n**Breaking changes**\n\n- Change the type of genotypes to ``int32_t``, removing the TSK_16_BIT_GENOTYPES flag option.\n (:user:`benjeffery`, :issue:`463`, :pr:`2108`)\n\n- ``tsk_variant_t`` now includes its ``tsk_site_t`` rather than pointing to it.\n (:user:`benjeffery`, :issue:`2161`, :pr:`2162`)\n\n- Rename ``TSK_TAKE_TABLES`` to ``TSK_TAKE_OWNERSHIP``.\n (:user:`benjeffery`, :issue:`2221`, :pr:`2222`)\n\n- ``TSK_DEBUG``, ``TSK_NO_INIT``, ``TSK_NO_CHECK_INTEGRITY`` and ``TSK_TAKE_OWNERSHIP`` have moved to ``core.h``\n (:user:`benjeffery`, :issue:`2218`, :pr:`2230`))\n\n- Rename several flags:\n - All flags to ``simplify`` for example ``TSK_KEEP_INPUT_ROOTS`` becomes ``TSK_SIMPLIFY_KEEP_INPUT_ROOTS``.\n - All flags to ``subset`` for example ``TSK_KEEP_UNREFERENCED`` becomes ``TSK_SUBSET_KEEP_UNREFERENCED``.\n - ``TSK_BUILD_INDEXES`` -> ``TSK_TS_INIT_BUILD_INDEXES``\n - ``TSK_NO_METADATA`` -> ``TSK_TABLE_NO_METADATA``\n - ``TSK_NO_EDGE_METADATA`` -> ``TSK_TC_NO_EDGE_METADATA``\n\n (:user:`benjeffery`, :issue:`1720`, :pr:`2226`, :pr:`2229`, :pr:`2224`)\n\n- Remove the generic ``TSK_ERR_OUT_OF_BOUNDS`` - replacing with specific errors.\n Remove ``TSK_ERR_NON_SINGLE_CHAR_MUTATION`` which was unused.\n (:user:`benjeffery`, :pr:`2260`)\n\n- Reorder stats API methods to place ``result`` as the last argument. (:user:`benjeffery`, :pr:`2292`, :issue:`2285`)\n\n**Features**\n\n- Make dumping of tables and tree sequences to disk a zero-copy operation.\n (:user:`benjeffery`, :issue:`2111`, :pr:`2124`)\n\n- Add ``edge`` attribute to ``mutation_t`` struct and make available in tree sequence.\n (:user:`jeromekelleher`, :issue:`685`, :pr:`2279`)\n\n- Reduce peak memory usage in ``tsk_treeseq_simplify``.\n (:user:`jeromekelleher`, :issue:`2287`, :pr:`2288`)\n\n----------------------\n[0.99.15] - 2021-12-07\n----------------------\n\n**Breaking changes**\n\n- The ``tables`` argument to ``tsk_treeseq_init`` is no longer ``const``, to allow for future no-copy tree sequence creation.\n (:user:`benjeffery`, :issue:`1718`, :pr:`1719`)\n- Additional consistency checks for mutation tables are now run by ``tsk_table_collection_check_integrity``\n even when ``TSK_CHECK_MUTATION_ORDERING`` is not passed in. (:user:`petrelharp`, :issue:`1713`, :pr:`1722`)\n\n- ``num_tracked_samples`` and ``num_samples`` in ``tsk_tree_t`` are now typed as ``tsk_size_t``\n (:user:`benjeffery`, :issue:`1723`, :pr:`1727`)\n\n- The previously deprecated option ``TSK_SAMPLE_COUNTS`` has been removed. (:user:`benjeffery`, :issue:`1744`, :pr:`1761`).\n- Individuals are no longer guaranteed or required to be topologically sorted in a tree sequence.\n ``tsk_table_collection_sort`` no longer sorts individuals.\n (:user:`benjeffery`, :issue:`1774`, :pr:`1789`)\n\n- The ``tsk_tree_t.left_root`` member has been removed. Client code can be updated\n most easily by using the equivalent ``tsk_tree_get_left_root`` function. However,\n it may be worth considering updating code to use either the standard traversal\n functions (which automatically iterate over roots) or to use the ``virtual_root``\n member (which may lead to more concise code). (:user:`jeromekelleher`, :issue:`1796`,\n :pr:`1862`)\n\n- Rename ``tsk_tree_t.left`` and ``tsk_tree_t.right`` members to\n ``tsk_tree_t.interval.left`` and ``tsk_tree_t.interval.right`` respectively.\n (:user:`jeromekelleher`, :issue:`1686`, :pr:`1913`)\n\n- ``kastore`` is now vendored into this repo instead of being a git submodule. Developers need to run\n ``git submodule update``. (:user:`jeromekelleher`, :issue:`1687`, :pr:`1973`)\n\n- ``Tree`` arrays such as ``left_sib``, ``right_child`` etc. now have an additional\n \"virtual root\" node at the end. (:user:`jeromekelleher`, :issue:`1691`, :pr:`1704`)\n\n- ``marked`` and ``mark`` have been removed from ``tsk_tree_t``. (:user:`jeromekelleher`, :pr:`1936`)\n\n**Features**\n\n- Add ``tsk_table_collection_individual_topological_sort`` to sort the individuals as this is no longer done by the\n default sort. (:user:`benjeffery`, :issue:`1774`, :pr:`1789`)\n\n- The default behaviour for table size growth is now to double the current size of the table,\n up to a threshold. To keep the previous behaviour, use (e.g.)\n ``tsk_edge_table_set_max_rows_increment(tables->edges, 1024)``, which results in adding\n space for 1024 additional rows each time we run out of space in the edge table.\n (:user:`benjeffery`, :issue:`5`, :pr:`1683`)\n- ``tsk_table_collection_check_integrity`` now has a ``TSK_CHECK_MIGRATION_ORDERING`` flag. (:user:`petrelharp`, :pr:`1722`)\n\n- The default behaviour for ragged column growth is now to double the current size of the column,\n up to a threshold. To keep the previous behaviour, use (e.g.)\n ``tsk_node_table_set_max_metadata_length_increment(tables->nodes, 1024)``, which results in adding\n space for 1024 additional entries each time we run out of space in the ragged column.\n (:user:`benjeffery`, :issue:`1703`, :pr:`1709`)\n\n- Support for compiling the C library on Windows using msys2 (:user:`jeromekelleher`,\n :pr:`1742`).\n\n- Add ``time_units`` to ``tsk_table_collection_t`` to describe the units of the time dimension of the\n tree sequence. This is then used to geerate an error if ``time_units`` is ``uncalibrated`` when\n using the branch lengths in statistics. (:user:`benjeffery`, :issue:`1644`, :pr:`1760`)\n\n- Add the ``TSK_LOAD_SKIP_TABLES`` option to load just the top-level information from a\n file. Also add the ``TSK_CMP_IGNORE_TABLES`` option to compare only the top-level\n information in two table collections. (:user:`clwgg`, :pr:`1882`, :issue:`1854`).\n\n- Add reference sequence.\n (:user:`jeromekelleher`, :user:`benjeffery`, :issue:`146`, :pr:`1911`, :pr:`1944`, :pr:`1911`)\n\n- Add the ``TSK_LOAD_SKIP_REFERENCE_SEQUENCE`` option to load a table collection\n without the reference sequence. Also add the TSK_CMP_IGNORE_REFERENCE_SEQUENCE\n option to compare two table collections without comparing their reference\n sequence. (:user:`clwgg`, :pr:`2019`, :issue:`1971`).\n\n- Add a \"virtual root\" to ``Tree`` arrays such as ``left_sib``, ``right_child`` etc.\n The virtual root is appended to each array, has all real roots as its children,\n but is not the parent of any node. Simplifies traversal algorithms.\n (:user:`jeromekelleher`, :issue:`1691`, :pr:`1704`)\n\n- Add ``num_edges`` to ``tsk_tree_t`` to count the edges that define the topology of\n the tree. (:user:`jeromekelleher`, :pr:`1704`)\n\n- Add the ``tsk_tree_get_size_bound`` function which returns an upper bound on the number of nodes reachable from\n the roots of a tree. Useful for tree stack allocations (:user:`jeromekelleher`, :pr:`1704`).\n\n- Add ``MetadataSchema.permissive_json`` for an easy way to get the simplest schema.\n\n\n----------------------\n[0.99.14] - 2021-09-03\n----------------------\n\n**Breaking changes**\n\n- 64 bits are now used to store the sizes of ragged table columns such as metadata,\n allowing them to hold more data. As such ``tsk_size_t`` is now 64 bits wide.\n This change is fully backwards and forwards compatible for all tree-sequences whose\n ragged column sizes fit into 32 bits. New tree-sequences with\n large offset arrays that require 64 bits will fail to load in previous versions with\n error ``TSK_ERR_BAD_COLUMN_TYPE``.\n (:user:`jeromekelleher`, :issue:`343`, :issue:`1527`, :issue:`1528`, :issue:`1530`,\n :issue:`1554`, :issue:`1573`, :issue:`1589`,:issue:`1598`,:issue:`1628`, :pr:`1571`,\n :pr:`1579`, :pr:`1585`, :pr:`1590`, :pr:`1602`, :pr:`1618`, :pr:`1620`, :pr:`1652`).\n\n**Features**\n\n- Add `tsk_X_table_update_row` methods which allow modifying single rows of tables\n (:user:`jeromekelleher`, :issue:`1545`, :pr:`1552`).\n\n----------------------\n[0.99.13] - 2021-07-08\n----------------------\n**Fixes**\n\n- Fix segfault when very large columns overflow\n (:user:`bhaller`, :user:`benjeffery`, :issue:`1509`, :pr:`1511`).\n\n----------------------\n[0.99.12] - 2021-05-14\n----------------------\n\n**Breaking changes**\n\n- Removed ``TSK_NO_BUILD_INDEXES``.\n Not building indexes is now the default behaviour of `tsk_table_collection_dump` and related functions.\n (:user:`molpopgen`, :issue:`1327`, :pr:`1337`).\n\n**Features**\n\n- Add ``tsk_*_table_extend`` methods to append to a table from another\n (:user:`benjeffery`, :issue:`1271`, :pr:`1287`).\n\n**Fixes**\n\n----------------------\n[0.99.11] - 2021-03-16\n----------------------\n\n**Features**\n\n- Add ``parents`` to the individual table to enable recording of pedigrees\n (:user:`ivan-krukov`, :user:`benjeffery`, :issue:`852`, :pr:`1125`, :pr:`866`, :pr:`1153`, :pr:`1177`, :pr:`1199`).\n\n- Added a ``tsk_table_collection_canonicalise`` method, that allows checking for equality between\n tables that are equivalent up to reordering (:user:`petrelharp`, :user:`mufernando`, :pr:`1108`).\n\n- Removed a previous requirement on ``tsk_table_collection_union``, allowing for unioning of\n new information both above and below shared history (:user:`petrelharp`, :user:`mufernando`, :pr:`1108`).\n\n- Support migrations in tsk_table_collection_sort. (:user:`jeromekelleher`,\n :issue:`22`, :issue:`117`, :pr:`1131`).\n\n**Breaking changes**\n\n- Method ``tsk_individual_table_add_row`` has an extra arguments ``parents`` and ``parents_length``.\n\n- Add an ``options`` argument to ``tsk_table_collection_subset`` (:user:`petrelharp`, :pr:`1108`),\n to allow for retaining the order of populations.\n\n- Mutation error codes have changed\n\n**Changes**\n\n- Allow mutations that have the same derived state as their parent mutation.\n (:user:`benjeffery`, :issue:`1180`, :pr:`1233`)\n\n- File minor version change to support individual parents\n\n----------------------\n[0.99.10] - 2021-01-25\n----------------------\n\nMinor bugfix on internal APIs\n\n---------------------\n[0.99.9] - 2021-01-22\n---------------------\n\n**Features**\n\n- Add ``TSK_SIMPLIFY_KEEP_UNARY_IN_INDIVIDUALS`` flag to simplify, which allows the user to\n keep unary nodes only if they belong to a tabled individual. This is useful for\n simplification in forwards simulations (:user:`hyanwong`, :issue:`1113`, :pr:`1119`).\n\n\n---------------------\n[0.99.8] - 2020-11-27\n---------------------\n\n**Features**\n\n- Add ``tsk_treeseq_genetic_relatedness`` for calculating genetic relatedness between\n pairs of sets of nodes (:user:`brieuclehmann`, :issue:`1021`, :pr:`1023`, :issue:`974`,\n :issue:`973`, :pr:`898`).\n\n- Exposed ``tsk_table_collection_set_indexes`` to the API\n (:user:`benjeffery`, :issue:`870`, :pr:`921`).\n\n**Breaking changes**\n\n- Added an ``options`` argument to ``tsk_table_collection_equals``\n and table equality methods to allow for more flexible equality criteria\n (e.g., ignore top-level metadata and schema or provenance tables).\n Existing code should add an extra final parameter ``0`` to retain the\n current behaviour (:user:`mufernando`, :user:`jeromekelleher`,\n :issue:`896`, :pr:`897`, :issue:`913`, :pr:`917`).\n\n- Changed default behaviour of ``tsk_table_collection_clear`` to not clear\n provenances and added ``options`` argument to optionally clear provenances\n and schemas (:user:`benjeffery`, :issue:`929`, :pr:`1001`).\n\n- Renamed ``ts.trait_regression`` to ``ts.trait_linear_model``.\n\n---------------------\n[0.99.7] - 2020-09-29\n---------------------\n\n- Added ``TSK_INCLUDE_TERMINAL`` option to ``tsk_diff_iter_init`` to output the last edges\n at the end of a tree sequence (:user:`hyanwong`, :issue:`783`, :pr:`787`).\n\n- Added ``tsk_bug_assert`` for assertions that should be compiled into release binaries\n (:user:`benjeffery`, :pr:`860`).\n\n---------------------\n[0.99.6] - 2020-09-04\n---------------------\n\n**Bugfixes**\n\n- :issue:`823` - Fix mutation time error when using\n ``tsk_table_collection_simplify`` with ``TSK_SIMPLIFY_KEEP_INPUT_ROOTS``\n (:user:`petrelharp`, :pr:`823`).\n\n---------------------\n[0.99.5] - 2020-08-27\n---------------------\n\n**Breaking changes**\n\n- The macro ``TSK_IMPUTE_MISSING_DATA`` is renamed to ``TSK_ISOLATED_NOT_MISSING``\n (:user:`benjeffery`, :issue:`716`, :pr:`794`)\n\n**New features**\n\n- Add a ``TSK_SIMPLIFY_KEEP_INPUT_ROOTS`` option to simplify which, if enabled, adds edges\n from the MRCAs of samples in the simplified tree sequence back to the roots\n in the input tree sequence (:user:`jeromekelleher`, :issue:`775`, :pr:`782`).\n\n**Bugfixes**\n\n- :issue:`777` - Mutations over isolated samples were incorrectly decoded as\n missing data. (:user:`jeromekelleher`, :pr:`778`)\n\n- :issue:`776` - Fix a segfault when a partial list of samples\n was provided to the ``variants`` iterator. (:user:`jeromekelleher`, :pr:`778`)\n\n---------------------\n[0.99.4] - 2020-08-12\n---------------------\n\n**Note**\n\n- The ``TSK_VERSION_PATCH`` macro was incorrectly set to ``4`` for 0.99.3, so both\n 0.99.4 and 0.99.3 have the same value.\n\n**Changes**\n\n- Mutation times can be a mixture of known and unknown as long as for each\n individual site they are either all known or all unknown (:user:`benjeffery`, :pr:`761`).\n\n**Bugfixes**\n\n- Fix for including core.h under C++ (:user:`petrelharp`, :pr:`755`).\n\n---------------------\n[0.99.3] - 2020-07-27\n---------------------\n\n**Breaking changes**\n\n- ``tsk_mutation_table_add_row`` has an extra ``time`` argument. If the time\n is unknown ``TSK_UNKNOWN_TIME`` should be passed.\n (:user:`benjeffery`, :pr:`672`)\n\n- Change genotypes from unsigned to signed to accommodate missing data\n (see :issue:`144` for discussion). This only affects users of the\n ``tsk_vargen_t`` class. Genotypes are now stored as int8_t and int16_t\n types rather than the former unsigned types. The field names in the\n genotypes union of the ``tsk_variant_t`` struct returned by ``tsk_vargen_next``\n have been renamed to ``i8`` and ``i16`` accordingly; care should be\n taken when updating client code to ensure that types are correct. The number\n of distinct alleles supported by 8 bit genotypes has therefore dropped\n from 255 to 127, with a similar reduction for 16 bit genotypes.\n\n- Change the ``tsk_vargen_init`` method to take an extra parameter ``alleles``.\n To keep the current behaviour, set this parameter to NULL.\n\n- Edges can now have metadata. Hence edge methods now take two extra arguments:\n metadata and metadata length. The file format has also changed to accommodate this,\n but is backwards compatible. Edge metadata can be disabled for a table collection with\n the TSK_NO_EDGE_METADATA flag.\n (:user:`benjeffery`, :pr:`496`, :pr:`712`)\n\n- Migrations can now have metadata. Hence migration methods now take two extra arguments:\n metadata and metadata length. The file format has also changed to accommodate this,\n but is backwards compatible.\n (:user:`benjeffery`, :pr:`505`)\n\n- The text dump of tables with metadata now includes the metadata schema as a header.\n (:user:`benjeffery`, :pr:`493`)\n\n- Bad tree topologies are detected earlier, so that it is no longer possible\n to create a tsk_treeseq_t object which contains a parent with contradictory\n children on an interval. Previously an error occured when some operation\n building the trees was attempted (:user:`jeromekelleher`, :pr:`709`).\n\n**New features**\n\n- New methods to perform set operations on table collections.\n ``tsk_table_collection_subset`` subsets and reorders table collections by nodes\n (:user:`mufernando`, :user:`petrelharp`, :pr:`663`, :pr:`690`).\n ``tsk_table_collection_union`` forms the node-wise union of two table collections\n (:user:`mufernando`, :user:`petrelharp`, :issue:`381`, :pr:`623`).\n\n- Mutations now have an optional double-precision floating-point ``time`` column.\n If not specified, this defaults to a particular NaN value (``TSK_UNKNOWN_TIME``)\n indicating that the time is unknown. For a tree sequence to be considered valid\n it must meet new criteria for mutation times, see :ref:`sec_mutation_requirements`.\n Add ``tsk_table_collection_compute_mutation_times`` and new flag to\n ``tsk_table_collection_check_integrity``:``TSK_CHECK_MUTATION_TIME``. Table sorting\n orders mutations by non-increasing time per-site, which is also a requirement for a\n valid tree sequence.\n (:user:`benjeffery`, :pr:`672`)\n\n- Add ``metadata`` and ``metadata_schema`` fields to table collection, with accessors on\n tree sequence. These store arbitrary bytes and are optional in the file format.\n (:user: `benjeffery`, :pr:`641`)\n\n- Add the ``TSK_SIMPLIFY_KEEP_UNARY`` option to simplify (:user:`gtsambos`). See :issue:`1`\n and :pr:`143`.\n\n- Add a ``set_root_threshold`` option to tsk_tree_t which allows us to set the\n number of samples a node must be an ancestor of to be considered a root\n (:pr:`462`).\n\n- Change the semantics of tsk_tree_t so that sample counts are always\n computed, and add a new ``TSK_NO_SAMPLE_COUNTS`` option to turn this\n off (:pr:`462`).\n\n- Tables with metadata now have an optional `metadata_schema` field that can contain\n arbitrary bytes. (:user:`benjeffery`, :pr:`493`)\n\n- Tables loaded from a file can now be edited in the same way as any other\n table collection (:user:`jeromekelleher`, :issue:`536`, :pr:`530`.\n\n- Support for reading/writing to arbitrary file streams with the loadf/dumpf\n variants for tree sequence and table collection load/dump\n (:user:`jeromekelleher`, :user:`grahamgower`, :issue:`565`, :pr:`599`).\n\n- Add low-level sorting API and ``TSK_NO_CHECK_INTEGRITY`` flag\n (:user:`jeromekelleher`, :pr:`627`, :issue:`626`).\n\n- Add extension of Kendall-Colijn tree distance metric for tree sequences\n computed by ``tsk_treeseq_kc_distance``\n (:user:`daniel-goldstein`, :pr:`548`)\n\n**Deprecated**\n\n- The ``TSK_SAMPLE_COUNTS`` options is now ignored and will print out a warning\n if used (:pr:`462`).\n\n---------------------\n[0.99.2] - 2019-03-27\n---------------------\n\nBugfix release. Changes:\n\n- Fix incorrect errors on tbl_collection_dump (#132)\n- Catch table overflows (#157)\n\n---------------------\n[0.99.1] - 2019-01-24\n---------------------\n\nRefinements to the C API as we move towards 1.0.0. Changes:\n\n- Change the ``_tbl_`` abbreviation to ``_table_`` to improve readability.\n Hence, we now have, e.g., ``tsk_node_table_t`` etc.\n- Change ``tsk_tbl_size_t`` to ``tsk_size_t``.\n- Standardise public API to use ``tsk_size_t`` and ``tsk_id_t`` as appropriate.\n- Add ``tsk_flags_t`` typedef and consistently use this as the type used to\n encode bitwise flags. To avoid confusion, functions now have an ``options``\n parameter.\n- Rename ``tsk_table_collection_position_t`` to ``tsk_bookmark_t``.\n- Rename ``tsk_table_collection_reset_position`` to ``tsk_table_collection_truncate``\n and ``tsk_table_collection_record_position`` to ``tsk_table_collection_record_num_rows``.\n- Generalise ``tsk_table_collection_sort`` to take a bookmark as start argument.\n- Relax restriction that nodes in the ``samples`` argument to simplify must\n currently be marked as samples. (https://github.com/tskit-dev/tskit/issues/72)\n- Allow ``tsk_table_collection_simplify`` to take a NULL samples argument to\n specify \"all samples in the current tables\".\n- Add support for building as a meson subproject.\n\n---------------------\n[0.99.0] - 2019-01-14\n---------------------\n\nInitial alpha version of the tskit C API tagged. Version 0.99.x\nrepresents the series of releases leading to version 1.0.0 which\nwill be the first stable release. After 1.0.0, semver rules\nregarding API/ABI breakage will apply; however, in the 0.99.x\nseries arbitrary changes may happen.\n\n--------------------\n[0.0.0] - 2019-01-10\n--------------------\n\nInitial extraction of tskit code from msprime. Relicense to MIT.\nCode copied at hash 29921408661d5fe0b1a82b1ca302a8b87510fd23\n"
},
{
"path": "c/VERSION.txt",
"content": "1.3.1"
},
{
"path": "c/examples/Makefile",
"content": "# Simple Makefile for building examples.\n# This will build the examples in the current directory by compiling in the\n# full tskit source into each of the examples. This is *not* recommended for\n# real projects!\n#\n# To use, type \"make\" in the this directory. If you have GSL installed you\n# should then get two example programs built.\n#\n# **Note**: This repo uses git submodules, and these must be checked out\n# correctly for this makefile to work, e.g.:\n#\n# $ git clone git@github.com:tskit-dev/tskit.git --recurse-submodules\n#\n# See the documentation (https://tskit.dev/tskit/docs/stable/c-api.html)\n# for more details on how to use the C API, and the tskit build examples\n# repo (https://github.com/tskit-dev/tskit-build-examples) for examples\n# of how to set up a production-ready build with tskit.\n#\n\nCFLAGS=-I../ -I../subprojects/kastore\nTSKIT_SOURCE=../tskit/*.c ../subprojects/kastore/kastore.c\n\ntargets = api_structure error_handling \\\n\thaploid_wright_fisher streaming \\\n\ttree_iteration tree_traversal \\\n\ttake_ownership \\\n\tjson_struct_metadata\n\nall: $(targets)\n\n$(targets): %: %.c\n\t${CC} ${CFLAGS} -o $@ $< ${TSKIT_SOURCE} -lm\n\nclean:\n\trm -f $(targets)\n\n"
},
{
"path": "c/examples/api_structure.c",
"content": "#include \n#include \n#include \n\n#define check_tsk_error(val) \\\n if (val < 0) { \\\n fprintf(stderr, \"line %d: %s\", __LINE__, tsk_strerror(val)); \\\n exit(EXIT_FAILURE); \\\n }\n\nint\nmain(int argc, char **argv)\n{\n int j, ret;\n tsk_edge_table_t edges;\n\n ret = tsk_edge_table_init(&edges, 0);\n check_tsk_error(ret);\n for (j = 0; j < 5; j++) {\n ret = tsk_edge_table_add_row(&edges, 0, 1, j + 1, j, NULL, 0);\n check_tsk_error(ret);\n }\n tsk_edge_table_print_state(&edges, stdout);\n tsk_edge_table_free(&edges);\n\n return EXIT_SUCCESS;\n}\n"
},
{
"path": "c/examples/cpp_sorting_example.cpp",
"content": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nstatic void\nhandle_tskit_return_code(int code)\n{\n if (code != 0) {\n std::ostringstream o;\n o << tsk_strerror(code);\n throw std::runtime_error(o.str());\n }\n}\n\nstruct edge_plus_time {\n double time;\n tsk_id_t parent, child;\n double left, right;\n};\n\nint\nsort_edges(tsk_table_sorter_t *sorter, tsk_size_t start)\n{\n if (sorter->tables->edges.metadata_length != 0) {\n throw std::invalid_argument(\n \"the sorter does not currently handle edge metadata\");\n }\n if (start != 0) {\n throw std::invalid_argument(\"the sorter requires start==0\");\n }\n\n std::vector temp;\n temp.reserve(static_cast(sorter->tables->edges.num_rows));\n\n auto edges = &sorter->tables->edges;\n auto nodes = &sorter->tables->nodes;\n\n for (tsk_size_t i = 0; i < sorter->tables->edges.num_rows; ++i) {\n temp.push_back(edge_plus_time{ nodes->time[edges->parent[i]], edges->parent[i],\n edges->child[i], edges->left[i], edges->right[i] });\n }\n\n std::sort(begin(temp), end(temp),\n [](const edge_plus_time &lhs, const edge_plus_time &rhs) {\n if (lhs.time == rhs.time) {\n if (lhs.parent == rhs.parent) {\n if (lhs.child == rhs.child) {\n return lhs.left < rhs.left;\n }\n return lhs.child < rhs.child;\n }\n return lhs.parent < rhs.parent;\n }\n return lhs.time < rhs.time;\n });\n\n for (std::size_t i = 0; i < temp.size(); ++i) {\n edges->left[i] = temp[i].left;\n edges->right[i] = temp[i].right;\n edges->parent[i] = temp[i].parent;\n edges->child[i] = temp[i].child;\n }\n\n return 0;\n}\n\nint\nmain(int argc, char **argv)\n{\n if (argc != 3) {\n std::cerr << \"Usage: \" << argv[0] << \" input.trees output.trees\\n\";\n std::exit(0);\n }\n const char *infile = argv[1];\n const char *outfile = argv[2];\n\n tsk_table_collection_t tables;\n auto ret = tsk_table_collection_load(&tables, infile, 0);\n handle_tskit_return_code(ret);\n\n tsk_table_sorter_t sorter;\n ret = tsk_table_sorter_init(&sorter, &tables, 0);\n handle_tskit_return_code(ret);\n sorter.sort_edges = sort_edges;\n try {\n ret = tsk_table_sorter_run(&sorter, NULL);\n } catch (std::exception &e) {\n std::cerr << e.what() << '\\n';\n std::exit(1);\n }\n handle_tskit_return_code(ret);\n ret = tsk_table_collection_dump(&tables, outfile, 0);\n handle_tskit_return_code(ret);\n ret = tsk_table_collection_free(&tables);\n handle_tskit_return_code(ret);\n}\n\n"
},
{
"path": "c/examples/error_handling.c",
"content": "#include \n#include \n#include \n\nint\nmain(int argc, char **argv)\n{\n int ret;\n tsk_treeseq_t ts;\n\n if (argc != 2) {\n fprintf(stderr, \"usage: \");\n exit(EXIT_FAILURE);\n }\n ret = tsk_treeseq_load(&ts, argv[1], 0);\n if (ret < 0) {\n /* Error condition. Free and exit */\n tsk_treeseq_free(&ts);\n fprintf(stderr, \"%s\", tsk_strerror(ret));\n exit(EXIT_FAILURE);\n }\n printf(\"Loaded tree sequence with %lld nodes and %lld edges from %s\\n\",\n (long long) tsk_treeseq_get_num_nodes(&ts),\n (long long) tsk_treeseq_get_num_edges(&ts), argv[1]);\n tsk_treeseq_free(&ts);\n\n return EXIT_SUCCESS;\n}\n"
},
{
"path": "c/examples/haploid_wright_fisher.c",
"content": "#include \n#include \n#include \n#include \n\n#include \n\n#define check_tsk_error(val) \\\n if (val < 0) { \\\n errx(EXIT_FAILURE, \"line %d: %s\", __LINE__, tsk_strerror(val)); \\\n }\n\nvoid\nsimulate(tsk_table_collection_t *tables, int N, int T, int simplify_interval)\n{\n tsk_id_t *buffer, *parents, *children, child, left_parent, right_parent;\n double breakpoint;\n int ret, j, t, b;\n\n assert(simplify_interval != 0); // leads to division by zero\n buffer = malloc(2 * N * sizeof(tsk_id_t));\n if (buffer == NULL) {\n errx(EXIT_FAILURE, \"Out of memory\");\n }\n tables->sequence_length = 1.0;\n parents = buffer;\n for (j = 0; j < N; j++) {\n parents[j]\n = tsk_node_table_add_row(&tables->nodes, 0, T, TSK_NULL, TSK_NULL, NULL, 0);\n check_tsk_error(parents[j]);\n }\n b = 0;\n for (t = T - 1; t >= 0; t--) {\n /* Alternate between using the first and last N values in the buffer */\n parents = buffer + (b * N);\n b = (b + 1) % 2;\n children = buffer + (b * N);\n for (j = 0; j < N; j++) {\n child = tsk_node_table_add_row(\n &tables->nodes, 0, t, TSK_NULL, TSK_NULL, NULL, 0);\n check_tsk_error(child);\n /* NOTE: the use of rand() is discouraged for\n * research code and proper random number generator\n * libraries should be preferred.\n */\n left_parent = parents[(size_t) ((rand() / (1. + RAND_MAX)) * N)];\n right_parent = parents[(size_t) ((rand() / (1. + RAND_MAX)) * N)];\n do {\n breakpoint = rand() / (1. + RAND_MAX);\n } while (breakpoint == 0); /* tiny proba of breakpoint being 0 */\n ret = tsk_edge_table_add_row(\n &tables->edges, 0, breakpoint, left_parent, child, NULL, 0);\n check_tsk_error(ret);\n ret = tsk_edge_table_add_row(\n &tables->edges, breakpoint, 1, right_parent, child, NULL, 0);\n check_tsk_error(ret);\n children[j] = child;\n }\n if (t % simplify_interval == 0) {\n printf(\"Simplify at generation %lld: (%lld nodes %lld edges)\", (long long) t,\n (long long) tables->nodes.num_rows, (long long) tables->edges.num_rows);\n /* Note: Edges must be sorted for simplify to work, and we use a brute force\n * approach of sorting each time here for simplicity. This is inefficient. */\n ret = tsk_table_collection_sort(tables, NULL, 0);\n check_tsk_error(ret);\n ret = tsk_table_collection_simplify(tables, children, N, 0, NULL);\n check_tsk_error(ret);\n printf(\" -> (%lld nodes %lld edges)\\n\", (long long) tables->nodes.num_rows,\n (long long) tables->edges.num_rows);\n for (j = 0; j < N; j++) {\n children[j] = j;\n }\n }\n }\n free(buffer);\n}\n\nint\nmain(int argc, char **argv)\n{\n int ret;\n tsk_table_collection_t tables;\n\n if (argc != 6) {\n errx(EXIT_FAILURE, \"usage: N T simplify-interval output-file seed\");\n }\n ret = tsk_table_collection_init(&tables, 0);\n check_tsk_error(ret);\n srand((unsigned) atoi(argv[5]));\n simulate(&tables, atoi(argv[1]), atoi(argv[2]), atoi(argv[3]));\n\n /* Sort and index so that the result can be opened as a tree sequence */\n ret = tsk_table_collection_sort(&tables, NULL, 0);\n check_tsk_error(ret);\n ret = tsk_table_collection_build_index(&tables, 0);\n check_tsk_error(ret);\n ret = tsk_table_collection_dump(&tables, argv[4], 0);\n check_tsk_error(ret);\n\n tsk_table_collection_free(&tables);\n return 0;\n}\n"
},
{
"path": "c/examples/json_struct_metadata.c",
"content": "#include \n#include \n#include \n#include \n#include \n\n// these are properties of the ``json+struct`` codec, documented in tskit\n#define JSON_STRUCT_HEADER_SIZE 21\n\nconst uint8_t json_struct_codec_magic[4] = { 'J', 'B', 'L', 'B' };\nconst uint8_t json_struct_codec_version = 1;\n\n// little-endian read of a uint64_t from an address\nstatic uint64_t\nload_u64_le(const uint8_t *p)\n{\n uint64_t value = (uint64_t) p[0];\n value |= (uint64_t) p[1] << 8;\n value |= (uint64_t) p[2] << 16;\n value |= (uint64_t) p[3] << 24;\n value |= (uint64_t) p[4] << 32;\n value |= (uint64_t) p[5] << 40;\n value |= (uint64_t) p[6] << 48;\n value |= (uint64_t) p[7] << 56;\n return value;\n}\n\n// little-endian write of a uint64_t to an address\nstatic void\nset_u64_le(uint8_t *dest, uint64_t value)\n{\n dest[0] = (uint8_t) (value & 0xFF);\n dest[1] = (uint8_t) ((value >> 8) & 0xFF);\n dest[2] = (uint8_t) ((value >> 16) & 0xFF);\n dest[3] = (uint8_t) ((value >> 24) & 0xFF);\n dest[4] = (uint8_t) ((value >> 32) & 0xFF);\n dest[5] = (uint8_t) ((value >> 40) & 0xFF);\n dest[6] = (uint8_t) ((value >> 48) & 0xFF);\n dest[7] = (uint8_t) ((value >> 56) & 0xFF);\n}\n\n// Extract the json and binary payloads from the `json+struct` codec data buffer.\n// Note that the output pointers `json` and `binary` reference memory\n// inside the `metadata` buffer passed in.\nvoid\njson_struct_codec_get_components(uint8_t *metadata, tsk_size_t metadata_length,\n uint8_t **json, tsk_size_t *json_length, uint8_t **binary, tsk_size_t *binary_length)\n{\n // check the structure of the codec header and the sizes it specifies\n if (metadata == NULL || json == NULL || json_length == NULL || binary == NULL\n || binary_length == NULL)\n errx(EXIT_FAILURE, \"bad parameter value.\");\n if (metadata_length < JSON_STRUCT_HEADER_SIZE)\n errx(EXIT_FAILURE, \"metadata truncated.\");\n if (memcmp(metadata, json_struct_codec_magic, sizeof(json_struct_codec_magic)) != 0)\n errx(EXIT_FAILURE, \"bad magic bytes.\");\n\n uint8_t version = metadata[4];\n if (version != json_struct_codec_version)\n errx(EXIT_FAILURE, \"bad version number.\");\n\n uint64_t json_length_u64 = load_u64_le(metadata + 5);\n uint64_t binary_length_u64 = load_u64_le(metadata + 13);\n if (json_length_u64 > UINT64_MAX - (uint64_t) JSON_STRUCT_HEADER_SIZE)\n errx(EXIT_FAILURE, \"invalid length.\");\n\n // determine the number of padding bytes and do more safety checks\n uint64_t length = (uint64_t) JSON_STRUCT_HEADER_SIZE + json_length_u64;\n uint64_t padding_length = (8 - (length & 0x07)) % 8;\n if (padding_length > UINT64_MAX - length)\n errx(EXIT_FAILURE, \"invalid length.\");\n\n length += padding_length;\n if (binary_length_u64 > UINT64_MAX - length)\n errx(EXIT_FAILURE, \"invalid length.\");\n\n length += binary_length_u64;\n if ((uint64_t) metadata_length != length)\n errx(EXIT_FAILURE, \"unexpected size.\");\n\n uint8_t *padding_start = metadata + JSON_STRUCT_HEADER_SIZE + json_length_u64;\n for (uint64_t j = 0; j < padding_length; ++j)\n if (*(padding_start + j) != 0)\n errx(EXIT_FAILURE, \"padding bytes are nonzero.\");\n\n // the structure of the codec data seems valid; return components\n *json = metadata + JSON_STRUCT_HEADER_SIZE;\n *json_length = (tsk_size_t) json_length_u64;\n\n *binary = metadata + JSON_STRUCT_HEADER_SIZE + json_length_u64 + padding_length;\n *binary_length = (tsk_size_t) binary_length_u64;\n}\n\n// malloc and return a data buffer for the `json+struct` codec\n// that contains the given components\nvoid\njson_struct_codec_create_buffer(const uint8_t *json, tsk_size_t json_length,\n const uint8_t *binary, tsk_size_t binary_length, uint8_t **buffer,\n tsk_size_t *buffer_length)\n{\n // figure out the total length of the codec's data and allocate the buffer for it\n tsk_size_t header_length = JSON_STRUCT_HEADER_SIZE;\n tsk_size_t padding_length = (8 - ((header_length + json_length) & 0x07)) % 8;\n tsk_size_t total_length\n = header_length + json_length + padding_length + binary_length;\n uint8_t *bytes = malloc(total_length);\n if (!bytes)\n errx(EXIT_FAILURE, \"memory for buffer could not be allocated.\");\n\n // then set up the bytes for the codec header\n memcpy(bytes, json_struct_codec_magic, 4);\n bytes[4] = json_struct_codec_version;\n set_u64_le(bytes + 5, (uint64_t) json_length);\n set_u64_le(bytes + 13, (uint64_t) binary_length);\n\n // copy in the JSON and binary data, separated by the padding bytes; the goal of the\n // padding bytes is to ensure that the binary data is 8-byte-aligned relative to the\n // start of the buffer\n memcpy(bytes + header_length, json, json_length);\n memset(bytes + header_length + json_length, 0, padding_length);\n memcpy(bytes + header_length + json_length + padding_length, binary, binary_length);\n\n // return the buffer and its length; the caller takes ownership of the buffer\n *buffer = bytes;\n *buffer_length = total_length;\n}\n\nint\nmain(int argc, char **argv)\n{\n // we start with JSON and binary payloads that we encode into a new buffer\n // note that the JSON payload does not have to end with a trailing NULL\n const char json_payload[] = { '{', '\"', 'a', '\"', ':', '1', '}' };\n const uint8_t binary_payload[] = { 0x01, 0x02, 0x03, 0x04 };\n uint8_t *metadata;\n tsk_size_t metadata_length;\n\n json_struct_codec_create_buffer((const uint8_t *) json_payload, sizeof(json_payload),\n binary_payload, sizeof(binary_payload), &metadata, &metadata_length);\n\n // then we decode that buffer to recover the json and binary data\n uint8_t *decoded_json, *decoded_binary;\n tsk_size_t decoded_json_length, decoded_binary_length;\n\n json_struct_codec_get_components(metadata, metadata_length, &decoded_json,\n &decoded_json_length, &decoded_binary, &decoded_binary_length);\n\n // print the recovered data to demonstrate that the round-trip worked\n // note that the JSON data is not NULL-terminated unless you put a NULL there!\n printf(\"JSON: %.*s\\n\", (int) decoded_json_length, decoded_json);\n\n printf(\"Binary data:\");\n for (tsk_size_t j = 0; j < decoded_binary_length; j++)\n printf(\" %#04x\", decoded_binary[j]);\n printf(\"\\n\");\n\n free(metadata);\n return EXIT_SUCCESS;\n}\n"
},
{
"path": "c/examples/multichrom_wright_fisher.c",
"content": "#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#define check_tsk_error(val) \\\n if (val < 0) { \\\n errx(EXIT_FAILURE, \"line %d: %s\\n\", __LINE__, tsk_strerror(val)); \\\n }\n\nstatic void\ninit_tables(tsk_table_collection_t *tcs, int num_chroms)\n{\n int j, ret;\n\n for (j = 0; j < num_chroms; j++) {\n ret = tsk_table_collection_init(&tcs[j], 0);\n check_tsk_error(ret);\n if (j > 0) {\n tsk_node_table_free(&tcs[j].nodes);\n }\n }\n}\n\nstatic void\nfree_tables(tsk_table_collection_t *tcs, int num_chroms)\n{\n int j;\n\n for (j = 0; j < num_chroms; j++) {\n if (j > 0) {\n /* Must not double free node table columns. */\n memset(&tcs[j].nodes, 0, sizeof(tcs[j].nodes));\n }\n tsk_table_collection_free(&tcs[j]);\n }\n}\n\nstatic void\njoin_tables(tsk_table_collection_t *tcs, int num_chroms)\n{\n int j, ret;\n\n for (j = 1; j < num_chroms; j++) {\n ret = tsk_edge_table_extend(\n &tcs[0].edges, &tcs[j].edges, tcs[j].edges.num_rows, NULL, 0);\n check_tsk_error(ret);\n }\n /* Get all the squashable edges next to each other */\n ret = tsk_table_collection_sort(&tcs[0], NULL, 0);\n check_tsk_error(ret);\n ret = tsk_edge_table_squash(&tcs[0].edges);\n check_tsk_error(ret);\n /* We need to sort again after squash */\n ret = tsk_table_collection_sort(&tcs[0], NULL, 0);\n check_tsk_error(ret);\n ret = tsk_table_collection_build_index(&tcs[0], 0);\n check_tsk_error(ret);\n}\n\nstruct chunk_work {\n int chunk;\n tsk_table_collection_t *tc;\n int *samples;\n int N;\n};\n\nvoid *\nsimplify_chunk(void *arg)\n{\n int ret;\n struct chunk_work *work = (struct chunk_work *) arg;\n tsk_size_t edges_before = work->tc->edges.num_rows;\n\n ret = tsk_table_collection_sort(work->tc, NULL, 0);\n check_tsk_error(ret);\n ret = tsk_table_collection_simplify(work->tc, work->samples, work->N,\n TSK_SIMPLIFY_NO_FILTER_NODES | TSK_SIMPLIFY_NO_UPDATE_SAMPLE_FLAGS, NULL);\n check_tsk_error(ret);\n /* NOTE: this printf makes helgrind complain */\n printf(\"\\tchunk %d: %lld -> %lld\\n\", work->chunk, (long long) edges_before,\n (long long) work->tc->edges.num_rows);\n\n return NULL;\n}\n\nvoid\nsort_and_simplify_all(tsk_table_collection_t *tcs, int num_chroms, int *samples, int N)\n{\n int j, ret;\n struct chunk_work work[num_chroms];\n pthread_t threads[num_chroms];\n\n for (j = 1; j < num_chroms; j++) {\n tcs[j].nodes = tcs[0].nodes;\n }\n\n for (j = 0; j < num_chroms; j++) {\n work[j].chunk = j;\n work[j].tc = &tcs[j];\n work[j].samples = samples;\n work[j].N = N;\n\n ret = pthread_create(&threads[j], NULL, simplify_chunk, (void *) &work[j]);\n if (ret != 0) {\n errx(EXIT_FAILURE, \"Pthread create failed\");\n }\n /* simplify_chunk((void *) &work[j]); */\n }\n for (j = 0; j < num_chroms; j++) {\n ret = pthread_join(threads[j], NULL);\n if (ret != 0) {\n errx(EXIT_FAILURE, \"Pthread join failed\");\n }\n }\n}\n\nvoid\nsimplify_tables(tsk_table_collection_t *tcs, int num_chroms, int *samples, int N)\n{\n int j, k, num_edges, ret;\n const tsk_size_t num_nodes = tcs[0].nodes.num_rows;\n tsk_bool_t *keep_nodes = malloc(num_nodes * sizeof(*keep_nodes));\n tsk_id_t *node_id_map = malloc(num_nodes * sizeof(*node_id_map));\n tsk_id_t *edge_child, *edge_parent;\n\n if (keep_nodes == NULL || node_id_map == NULL) {\n errx(EXIT_FAILURE, \"Out of memory\");\n }\n\n printf(\"Simplify %lld nodes\\n\", (long long) tcs[0].nodes.num_rows);\n sort_and_simplify_all(tcs, num_chroms, samples, N);\n\n for (j = 0; j < num_nodes; j++) {\n keep_nodes[j] = false;\n tcs[0].nodes.flags[j] &= (~TSK_NODE_IS_SAMPLE);\n }\n for (j = 0; j < N; j++) {\n keep_nodes[samples[j]] = true;\n tcs[0].nodes.flags[samples[j]] |= TSK_NODE_IS_SAMPLE;\n }\n\n for (j = 0; j < num_chroms; j++) {\n edge_child = tcs[j].edges.child;\n edge_parent = tcs[j].edges.parent;\n num_edges = tcs[j].edges.num_rows;\n for (k = 0; k < num_edges; k++) {\n keep_nodes[edge_child[k]] = true;\n keep_nodes[edge_parent[k]] = true;\n }\n }\n tsk_node_table_keep_rows(&tcs[0].nodes, keep_nodes, 0, node_id_map);\n printf(\"\\tdone: %lld nodes\\n\", (long long) tcs[0].nodes.num_rows);\n\n /* Remap node references */\n for (j = 0; j < num_chroms; j++) {\n edge_child = tcs[j].edges.child;\n edge_parent = tcs[j].edges.parent;\n num_edges = tcs[j].edges.num_rows;\n for (k = 0; k < num_edges; k++) {\n edge_child[k] = node_id_map[edge_child[k]];\n edge_parent[k] = node_id_map[edge_parent[k]];\n }\n ret = tsk_table_collection_check_integrity(&tcs[j], 0);\n check_tsk_error(ret);\n }\n for (j = 0; j < N; j++) {\n samples[j] = node_id_map[samples[j]];\n }\n free(keep_nodes);\n free(node_id_map);\n}\n\nvoid\nsimulate(\n tsk_table_collection_t *tcs, int num_chroms, int N, int T, int simplify_interval)\n{\n tsk_id_t *buffer, *parents, *children, child, left_parent, right_parent;\n bool left_is_first;\n double chunk_left, chunk_right;\n int ret, j, t, b, k;\n\n assert(simplify_interval != 0); // leads to division by zero\n buffer = malloc(2 * N * sizeof(tsk_id_t));\n if (buffer == NULL) {\n errx(EXIT_FAILURE, \"Out of memory\");\n }\n for (k = 0; k < num_chroms; k++) {\n tcs[k].sequence_length = num_chroms;\n }\n parents = buffer;\n for (j = 0; j < N; j++) {\n parents[j]\n = tsk_node_table_add_row(&tcs[0].nodes, 0, T, TSK_NULL, TSK_NULL, NULL, 0);\n check_tsk_error(parents[j]);\n }\n b = 0;\n for (t = T - 1; t >= 0; t--) {\n /* Alternate between using the first and last N values in the buffer */\n parents = buffer + (b * N);\n b = (b + 1) % 2;\n children = buffer + (b * N);\n for (j = 0; j < N; j++) {\n child = tsk_node_table_add_row(\n &tcs[0].nodes, 0, t, TSK_NULL, TSK_NULL, NULL, 0);\n check_tsk_error(child);\n /* NOTE: the use of rand() is discouraged for\n * research code and proper random number generator\n * libraries should be preferred.\n */\n left_parent = parents[(size_t) ((rand() / (1. + RAND_MAX)) * N)];\n right_parent = parents[(size_t) ((rand() / (1. + RAND_MAX)) * N)];\n left_is_first = rand() < 0.5;\n chunk_left = 0.0;\n for (k = 0; k < num_chroms; k++) {\n chunk_right = chunk_left + rand() / (1. + RAND_MAX);\n /* a very tiny chance that right and left are equal */\n if (chunk_right > chunk_left) {\n ret = tsk_edge_table_add_row(&tcs[k].edges, chunk_left, chunk_right,\n left_is_first ? left_parent : right_parent, child, NULL, 0);\n check_tsk_error(ret);\n }\n chunk_left += 1.0;\n if (chunk_right < chunk_left) {\n ret = tsk_edge_table_add_row(&tcs[k].edges, chunk_right, chunk_left,\n left_is_first ? right_parent : left_parent, child, NULL, 0);\n check_tsk_error(ret);\n }\n }\n children[j] = child;\n }\n if (t % simplify_interval == 0) {\n simplify_tables(tcs, num_chroms, children, N);\n }\n }\n /* Set the sample flags for final generation */\n for (j = 0; j < N; j++) {\n tcs[0].nodes.flags[children[j]] = TSK_NODE_IS_SAMPLE;\n }\n free(buffer);\n}\n\nint\nmain(int argc, char **argv)\n{\n int ret;\n int num_chroms;\n\n if (argc != 7) {\n errx(EXIT_FAILURE, \"usage: N T simplify-interval output seed num-chroms\");\n }\n\n num_chroms = atoi(argv[6]);\n tsk_table_collection_t tcs[num_chroms];\n\n srand((unsigned) atoi(argv[5]));\n init_tables(tcs, num_chroms);\n simulate(tcs, num_chroms, atoi(argv[1]), atoi(argv[2]), atoi(argv[3]));\n join_tables(tcs, num_chroms);\n ret = tsk_table_collection_dump(&tcs[0], argv[4], 0);\n check_tsk_error(ret);\n free_tables(tcs, num_chroms);\n\n return 0;\n}\n"
},
{
"path": "c/examples/multichrom_wright_fisher_singlethreaded.c",
"content": "#include \n#include \n#include \n#include \n#include \n\n#include \n\n#define check_tsk_error(val) \\\n if (val < 0) { \\\n errx(EXIT_FAILURE, \"line %d: %s\\n\", __LINE__, tsk_strerror(val)); \\\n }\n\nvoid\nsimulate(\n tsk_table_collection_t *tables, int num_chroms, int N, int T, int simplify_interval)\n{\n tsk_id_t *buffer, *parents, *children, child, left_parent, right_parent;\n bool left_is_first;\n double chunk_left, chunk_right;\n int ret, j, t, b, k;\n\n assert(simplify_interval != 0); // leads to division by zero\n buffer = malloc(2 * N * sizeof(tsk_id_t));\n if (buffer == NULL) {\n errx(EXIT_FAILURE, \"Out of memory\");\n }\n tables->sequence_length = num_chroms;\n parents = buffer;\n for (j = 0; j < N; j++) {\n parents[j]\n = tsk_node_table_add_row(&tables->nodes, 0, T, TSK_NULL, TSK_NULL, NULL, 0);\n check_tsk_error(parents[j]);\n }\n b = 0;\n for (t = T - 1; t >= 0; t--) {\n /* Alternate between using the first and last N values in the buffer */\n parents = buffer + (b * N);\n b = (b + 1) % 2;\n children = buffer + (b * N);\n for (j = 0; j < N; j++) {\n child = tsk_node_table_add_row(\n &tables->nodes, 0, t, TSK_NULL, TSK_NULL, NULL, 0);\n check_tsk_error(child);\n /* NOTE: the use of rand() is discouraged for\n * research code and proper random number generator\n * libraries should be preferred.\n */\n left_parent = parents[(size_t) ((rand() / (1. + RAND_MAX)) * N)];\n right_parent = parents[(size_t) ((rand() / (1. + RAND_MAX)) * N)];\n left_is_first = rand() < 0.5;\n chunk_left = 0.0;\n for (k = 0; k < num_chroms; k++) {\n chunk_right = chunk_left + rand() / (1. + RAND_MAX);\n /* a very tiny chance that right and left are equal */\n if (chunk_right > chunk_left) {\n ret = tsk_edge_table_add_row(&tables->edges, chunk_left, chunk_right,\n left_is_first ? left_parent : right_parent, child, NULL, 0);\n check_tsk_error(ret);\n }\n chunk_left += 1.0;\n if (chunk_right < chunk_left) {\n ret = tsk_edge_table_add_row(&tables->edges, chunk_right, chunk_left,\n left_is_first ? right_parent : left_parent, child, NULL, 0);\n check_tsk_error(ret);\n }\n }\n children[j] = child;\n }\n if (t % simplify_interval == 0) {\n printf(\"Simplify at generation %lld: (%lld nodes %lld edges)\", (long long) t,\n (long long) tables->nodes.num_rows, (long long) tables->edges.num_rows);\n /* Note: Edges must be sorted for simplify to work, and we use a brute force\n * approach of sorting each time here for simplicity. This is inefficient. */\n ret = tsk_table_collection_sort(tables, NULL, 0);\n check_tsk_error(ret);\n ret = tsk_table_collection_simplify(tables, children, N, 0, NULL);\n check_tsk_error(ret);\n printf(\" -> (%lld nodes %lld edges)\\n\", (long long) tables->nodes.num_rows,\n (long long) tables->edges.num_rows);\n for (j = 0; j < N; j++) {\n children[j] = j;\n }\n }\n }\n /* Set the sample flags for final generation */\n for (j = 0; j < N; j++) {\n tables->nodes.flags[children[j]] = TSK_NODE_IS_SAMPLE;\n }\n free(buffer);\n}\n\nint\nmain(int argc, char **argv)\n{\n int ret;\n tsk_table_collection_t tables;\n\n if (argc != 7) {\n errx(EXIT_FAILURE, \"usage: N T simplify-interval output seed num-chroms\");\n }\n ret = tsk_table_collection_init(&tables, 0);\n check_tsk_error(ret);\n srand((unsigned) atoi(argv[5]));\n simulate(&tables, atoi(argv[6]), atoi(argv[1]), atoi(argv[2]), atoi(argv[3]));\n\n /* Sort and index so that the result can be opened as a tree sequence */\n ret = tsk_table_collection_sort(&tables, NULL, 0);\n check_tsk_error(ret);\n ret = tsk_table_collection_build_index(&tables, 0);\n check_tsk_error(ret);\n ret = tsk_table_collection_dump(&tables, argv[4], 0);\n check_tsk_error(ret);\n\n tsk_table_collection_free(&tables);\n return 0;\n}\n"
},
{
"path": "c/examples/streaming.c",
"content": "#include \n#include \n#include \n\n#define check_tsk_error(val) \\\n if (val < 0) { \\\n fprintf(stderr, \"Error: line %d: %s\\n\", __LINE__, tsk_strerror(val)); \\\n exit(EXIT_FAILURE); \\\n }\n\nint\nmain(int argc, char **argv)\n{\n int ret;\n int j = 0;\n tsk_table_collection_t tables;\n\n ret = tsk_table_collection_init(&tables, 0);\n check_tsk_error(ret);\n\n while (true) {\n ret = tsk_table_collection_loadf(&tables, stdin, TSK_NO_INIT);\n if (ret == TSK_ERR_EOF) {\n break;\n }\n check_tsk_error(ret);\n fprintf(stderr, \"Tree sequence %d had %lld mutations\\n\", j,\n (long long) tables.mutations.num_rows);\n ret = tsk_mutation_table_truncate(&tables.mutations, 0);\n check_tsk_error(ret);\n ret = tsk_table_collection_dumpf(&tables, stdout, 0);\n check_tsk_error(ret);\n j++;\n }\n tsk_table_collection_free(&tables);\n return EXIT_SUCCESS;\n}\n"
},
{
"path": "c/examples/take_ownership.c",
"content": "#include \n#include \n#include \n#include \n\n#define check_tsk_error(val) \\\n if (val < 0) { \\\n errx(EXIT_FAILURE, \"line %d: %s\", __LINE__, tsk_strerror(val)); \\\n }\n\nint\nmain(int argc, char **argv)\n{\n tsk_table_collection_t *tables;\n tsk_treeseq_t treeseq;\n int rv;\n\n tables = malloc(sizeof(*tables));\n rv = tsk_table_collection_init(tables, 0);\n check_tsk_error(rv);\n\n /* NOTE: you must set sequence length AFTER initialization */\n tables->sequence_length = 1.0;\n\n /* Do your regular table operations */\n rv = tsk_node_table_add_row(&tables->nodes, 0, 0.0, -1, -1, NULL, 0);\n check_tsk_error(rv);\n\n /* Initalize the tree sequence, transferring all responsibility\n * for the table collection's memory managment\n */\n rv = tsk_treeseq_init(\n &treeseq, tables, TSK_TS_INIT_BUILD_INDEXES | TSK_TAKE_OWNERSHIP);\n check_tsk_error(rv);\n\n /* WARNING: calling tsk_table_collection_free is now a memory error! */\n tsk_treeseq_free(&treeseq);\n}\n"
},
{
"path": "c/examples/tree_iteration.c",
"content": "#include \n#include \n#include \n\n#include \n\n#define check_tsk_error(val) \\\n if (val < 0) { \\\n errx(EXIT_FAILURE, \"line %d: %s\", __LINE__, tsk_strerror(val)); \\\n }\n\nint\nmain(int argc, char **argv)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t tree;\n\n if (argc != 2) {\n errx(EXIT_FAILURE, \"usage: \");\n }\n ret = tsk_treeseq_load(&ts, argv[1], 0);\n check_tsk_error(ret);\n ret = tsk_tree_init(&tree, &ts, 0);\n check_tsk_error(ret);\n\n printf(\"Iterate forwards\\n\");\n for (ret = tsk_tree_first(&tree); ret == TSK_TREE_OK; ret = tsk_tree_next(&tree)) {\n printf(\"\\ttree %lld has %lld roots\\n\", (long long) tree.index,\n (long long) tsk_tree_get_num_roots(&tree));\n }\n check_tsk_error(ret);\n\n printf(\"Iterate backwards\\n\");\n for (ret = tsk_tree_last(&tree); ret == TSK_TREE_OK; ret = tsk_tree_prev(&tree)) {\n printf(\"\\ttree %lld has %lld roots\\n\", (long long) tree.index,\n (long long) tsk_tree_get_num_roots(&tree));\n }\n check_tsk_error(ret);\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n return 0;\n}\n"
},
{
"path": "c/examples/tree_traversal.c",
"content": "#include \n#include \n#include \n\n#include \n\n#define check_tsk_error(val) \\\n if (val < 0) { \\\n errx(EXIT_FAILURE, \"line %d: %s\", __LINE__, tsk_strerror(val)); \\\n }\n\nstatic void\ntraverse_standard(const tsk_tree_t *tree)\n{\n int ret;\n tsk_size_t num_nodes, j;\n tsk_id_t *nodes = malloc(tsk_tree_get_size_bound(tree) * sizeof(*nodes));\n\n if (nodes == NULL) {\n errx(EXIT_FAILURE, \"Out of memory\");\n }\n ret = tsk_tree_preorder(tree, nodes, &num_nodes);\n check_tsk_error(ret);\n for (j = 0; j < num_nodes; j++) {\n printf(\"Visit preorder %lld\\n\", (long long) nodes[j]);\n }\n\n ret = tsk_tree_postorder(tree, nodes, &num_nodes);\n check_tsk_error(ret);\n for (j = 0; j < num_nodes; j++) {\n printf(\"Visit postorder %lld\\n\", (long long) nodes[j]);\n }\n\n free(nodes);\n}\n\nstatic void\n_traverse(const tsk_tree_t *tree, tsk_id_t u, int depth)\n{\n tsk_id_t v;\n int j;\n\n for (j = 0; j < depth; j++) {\n printf(\" \");\n }\n printf(\"Visit recursive %lld\\n\", (long long) u);\n for (v = tree->left_child[u]; v != TSK_NULL; v = tree->right_sib[v]) {\n _traverse(tree, v, depth + 1);\n }\n}\n\nstatic void\ntraverse_recursive(const tsk_tree_t *tree)\n{\n _traverse(tree, tree->virtual_root, -1);\n}\n\nstatic void\ntraverse_stack(const tsk_tree_t *tree)\n{\n int stack_top;\n tsk_id_t u, v;\n tsk_id_t *stack = malloc(tsk_tree_get_size_bound(tree) * sizeof(*stack));\n\n if (stack == NULL) {\n errx(EXIT_FAILURE, \"Out of memory\");\n }\n stack_top = 0;\n stack[stack_top] = tree->virtual_root;\n while (stack_top >= 0) {\n u = stack[stack_top];\n stack_top--;\n printf(\"Visit stack %lld\\n\", (long long) u);\n /* Put nodes on the stack right-to-left, so we visit in left-to-right */\n for (v = tree->right_child[u]; v != TSK_NULL; v = tree->left_sib[v]) {\n stack_top++;\n stack[stack_top] = v;\n }\n }\n free(stack);\n}\n\nstatic void\ntraverse_upwards(const tsk_tree_t *tree)\n{\n const tsk_id_t *samples = tsk_treeseq_get_samples(tree->tree_sequence);\n tsk_size_t num_samples = tsk_treeseq_get_num_samples(tree->tree_sequence);\n tsk_size_t j;\n tsk_id_t u;\n\n for (j = 0; j < num_samples; j++) {\n u = samples[j];\n while (u != TSK_NULL) {\n printf(\"Visit upwards: %lld\\n\", (long long) u);\n u = tree->parent[u];\n }\n }\n}\n\nint\nmain(int argc, char **argv)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t tree;\n\n if (argc != 2) {\n errx(EXIT_FAILURE, \"usage: \");\n }\n ret = tsk_treeseq_load(&ts, argv[1], 0);\n check_tsk_error(ret);\n ret = tsk_tree_init(&tree, &ts, 0);\n check_tsk_error(ret);\n ret = tsk_tree_first(&tree);\n check_tsk_error(ret);\n\n traverse_standard(&tree);\n\n traverse_recursive(&tree);\n\n traverse_stack(&tree);\n\n traverse_upwards(&tree);\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n return 0;\n}\n"
},
{
"path": "c/meson.build",
"content": "project('tskit', ['c', 'cpp'],\n version: files('VERSION.txt'), \n default_options: ['c_std=c99', 'cpp_std=c++11']\n)\n\ndebug_c_args = []\nif get_option('buildtype').startswith('debug')\n debug_c_args = ['-DTSK_TRACE_ERRORS']\nendif\n\nkastore_proj = subproject('kastore')\nkastore_dep = kastore_proj.get_variable('kastore_dep')\nkastore_inc = kastore_proj.get_variable('kastore_inc')\n\ncc = meson.get_compiler('c')\nm_dep = cc.find_library('m', required: false)\nlib_deps = [m_dep, kastore_dep]\n\nextra_c_args = [\n '-Wall', '-Wextra', '-Werror', '-Wpedantic', '-W',\n '-Wmissing-prototypes', '-Wstrict-prototypes',\n '-Wconversion', '-Wshadow', '-Wpointer-arith', '-Wcast-align',\n '-Wcast-qual', '-Wwrite-strings', '-Wnested-externs',\n '-fshort-enums', '-fno-common'] + debug_c_args\n\nlib_sources = [\n 'tskit/core.c', 'tskit/tables.c', 'tskit/trees.c',\n 'tskit/genotypes.c', 'tskit/stats.c', 'tskit/convert.c', 'tskit/haplotype_matching.c']\nlib_headers = [\n 'tskit/core.h', 'tskit/tables.h', 'tskit/trees.h',\n 'tskit/genotypes.h', 'tskit/stats.h', 'tskit/convert.h', 'tskit/haplotype_matching.h']\n\n# Subprojects use the static library for simplicity.\ntskit_inc = [kastore_inc, include_directories(['.'])]\ntskit_lib = static_library('tskit',\n sources: lib_sources, dependencies: lib_deps)\ntskit_dep = declare_dependency(include_directories:tskit_inc, link_with: tskit_lib)\n\nif not meson.is_subproject()\n\n # Shared library install target.\n shared_library('tskit',\n sources: lib_sources, dependencies: lib_deps, c_args: extra_c_args, install: true)\n install_headers('tskit.h')\n install_headers(lib_headers, subdir: 'tskit')\n\n cunit_dep = dependency('cunit')\n # We don't specify extra C args here as CUnit won't pass the checks.\n test_lib = static_library('testlib',\n sources: ['tests/testlib.c'], dependencies: [cunit_dep, kastore_dep, tskit_dep])\n\n test_core = executable('test_core',\n sources: ['tests/test_core.c'],\n link_with: [tskit_lib, test_lib],\n c_args: extra_c_args+['-DMESON_PROJECT_VERSION=\"@0@\"'.format(meson.project_version())],\n dependencies: kastore_dep,\n )\n test('core', test_core)\n\n test_tables = executable('test_tables',\n sources: ['tests/test_tables.c'],\n link_with: [tskit_lib, test_lib], c_args: extra_c_args, dependencies: kastore_dep)\n test('tables', test_tables)\n\n test_trees = executable('test_trees',\n sources: ['tests/test_trees.c'],\n link_with: [tskit_lib, test_lib], c_args: extra_c_args, dependencies: kastore_dep)\n test('trees', test_trees)\n\n test_genotypes = executable('test_genotypes',\n sources: ['tests/test_genotypes.c'],\n link_with: [tskit_lib, test_lib], c_args: extra_c_args, dependencies: kastore_dep)\n test('genotypes', test_genotypes)\n\n test_convert = executable('test_convert',\n sources: ['tests/test_convert.c'],\n link_with: [tskit_lib, test_lib], c_args: extra_c_args, dependencies: kastore_dep)\n test('convert', test_convert)\n\n test_stats = executable('test_stats',\n sources: ['tests/test_stats.c'],\n link_with: [tskit_lib, test_lib], c_args: extra_c_args, dependencies: kastore_dep)\n test('stats', test_stats)\n\n test_haplotype_matching = executable('test_haplotype_matching',\n sources: ['tests/test_haplotype_matching.c'],\n link_with: [tskit_lib, test_lib], c_args: extra_c_args, dependencies: kastore_dep)\n test('haplotype_matching', test_haplotype_matching)\n\n test_file_format = executable('test_file_format',\n sources: ['tests/test_file_format.c'],\n link_with: [tskit_lib, test_lib], c_args: extra_c_args, dependencies: kastore_dep)\n test('file_format', test_file_format)\n\n test_minimal_cpp = executable('test_minimal_cpp',\n sources: ['tests/test_minimal_cpp.cpp'], link_with: [tskit_lib],\n dependencies: kastore_dep)\n test('minimal_cpp', test_minimal_cpp)\n\n if get_option('build_examples')\n # These example programs use less portable features,\n # and we don't want to always compile them. Use, e.g.,\n # meson build -Dbuild_examples=false\n executable('api_structure',\n sources: ['examples/api_structure.c'], \n link_with: [tskit_lib], dependencies: lib_deps)\n executable('error_handling',\n sources: ['examples/error_handling.c'], \n link_with: [tskit_lib], dependencies: lib_deps)\n executable('tree_iteration',\n sources: ['examples/tree_iteration.c'], \n link_with: [tskit_lib], dependencies: lib_deps)\n executable('tree_traversal',\n sources: ['examples/tree_traversal.c'], \n link_with: [tskit_lib], dependencies: lib_deps)\n executable('streaming',\n sources: ['examples/streaming.c'], \n link_with: [tskit_lib], dependencies: lib_deps)\n executable('cpp_sorting_example',\n sources: ['examples/cpp_sorting_example.cpp'], \n link_with: [tskit_lib], dependencies: lib_deps)\n executable('haploid_wright_fisher',\n sources: ['examples/haploid_wright_fisher.c'], \n link_with: [tskit_lib], dependencies: lib_deps)\n executable('multichrom_wright_fisher_singlethreaded',\n sources: ['examples/multichrom_wright_fisher_singlethreaded.c'], \n link_with: [tskit_lib], dependencies: lib_deps)\n executable('json_struct_metadata',\n sources: ['examples/json_struct_metadata.c'], \n link_with: [tskit_lib], dependencies: lib_deps)\n\n thread_dep = dependency('threads')\n executable('multichrom_wright_fisher',\n sources: ['examples/multichrom_wright_fisher.c'], \n link_with: [tskit_lib], dependencies: [m_dep, kastore_dep, thread_dep])\n endif\nendif\n"
},
{
"path": "c/meson_options.txt",
"content": "option('build_examples', type : 'boolean', value : true)\n"
},
{
"path": "c/subprojects/kastore/README.md",
"content": "This directory is an abbreviated version of the kastore distribution source.\n\nAll files should be updated when we are updating to a new kastore version.\n"
},
{
"path": "c/subprojects/kastore/VERSION.txt",
"content": "2.1.2\n"
},
{
"path": "c/subprojects/kastore/kastore.c",
"content": "#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"kastore.h\"\n\n/* Private flag used to indicate when we have opened the file ourselves\n * and need to free it. */\n/* Note: we use 1<<14 to keep this flag at the end of the flag space,\n * and this is the highest bit that can be guaranteed to fit into\n * an int. */\n#define OWN_FILE (1 << 14)\n\nconst char *\nkas_strerror(int err)\n{\n const char *ret = \"Unknown error\";\n\n switch (err) {\n case KAS_ERR_GENERIC:\n ret = \"Generic error; please file a bug report\";\n break;\n case KAS_ERR_IO:\n if (errno != 0) {\n ret = strerror(errno);\n } else {\n ret = \"I/O error with errno unset. Please file a bug report\";\n }\n break;\n case KAS_ERR_BAD_MODE:\n ret = \"Bad open mode; must be \\\"r\\\", \\\"w\\\", or \\\"a\\\"\";\n break;\n case KAS_ERR_BAD_FLAGS:\n ret = \"Unknown flags specified. Only (KAS_GET_TAKES_OWNERSHIP and/or\"\n \"KAS_READ_ALL) or 0 can be specified \"\n \"for open, and KAS_BORROWS_ARRAY or 0 for put\";\n break;\n case KAS_ERR_NO_MEMORY:\n ret = \"Out of memory\";\n break;\n case KAS_ERR_BAD_FILE_FORMAT:\n ret = \"File not in KAS format\";\n break;\n case KAS_ERR_VERSION_TOO_OLD:\n ret = \"File format version is too old. Please upgrade using \"\n \"'kas upgrade '\";\n break;\n case KAS_ERR_VERSION_TOO_NEW:\n ret = \"File format version is too new. Please upgrade your \"\n \"kastore library version\";\n break;\n case KAS_ERR_BAD_TYPE:\n ret = \"Unknown data type\";\n break;\n case KAS_ERR_DUPLICATE_KEY:\n ret = \"Duplicate key provided\";\n break;\n case KAS_ERR_KEY_NOT_FOUND:\n ret = \"Key not found\";\n break;\n case KAS_ERR_EMPTY_KEY:\n ret = \"Keys cannot be empty\";\n break;\n case KAS_ERR_ILLEGAL_OPERATION:\n ret = \"Cannot perform the requested operation in the current mode\";\n break;\n case KAS_ERR_TYPE_MISMATCH:\n ret = \"Mismatch between requested and stored types for array\";\n break;\n case KAS_ERR_EOF:\n ret = \"End of file\";\n break;\n }\n return ret;\n}\n\nkas_version_t\nkas_version(void)\n{\n kas_version_t version;\n\n version.major = KAS_VERSION_MAJOR;\n version.minor = KAS_VERSION_MINOR;\n version.patch = KAS_VERSION_PATCH;\n return version;\n}\n\nstatic size_t\ntype_size(int type)\n{\n const size_t type_size_map[] = { 1, 1, 2, 2, 4, 4, 8, 8, 4, 8 };\n assert(type < KAS_NUM_TYPES);\n return type_size_map[type];\n}\n\n/* Compare item keys lexicographically. */\nstatic int\ncompare_items(const void *a, const void *b)\n{\n const kaitem_t *ia = (const kaitem_t *) a;\n const kaitem_t *ib = (const kaitem_t *) b;\n size_t len = ia->key_len < ib->key_len ? ia->key_len : ib->key_len;\n int ret = memcmp(ia->key, ib->key, len);\n if (ret == 0) {\n ret = (ia->key_len > ib->key_len) - (ia->key_len < ib->key_len);\n }\n return ret;\n}\n\n/* When a read error occurs we don't know whether this is because the file\n * ended unexpectedly or an IO error occured. If the file ends unexpectedly\n * this is a file format error.\n */\nstatic int KAS_WARN_UNUSED\nkastore_get_read_io_error(kastore_t *self)\n{\n int ret = KAS_ERR_IO;\n\n if (feof(self->file) || errno == 0) {\n ret = KAS_ERR_BAD_FILE_FORMAT;\n }\n return ret;\n}\n\nstatic int KAS_WARN_UNUSED\nkastore_write_header(kastore_t *self)\n{\n int ret = 0;\n char header[KAS_HEADER_SIZE];\n uint16_t version_major = KAS_FILE_VERSION_MAJOR;\n uint16_t version_minor = KAS_FILE_VERSION_MINOR;\n uint32_t num_items = (uint32_t) self->num_items;\n uint64_t file_size = (uint64_t) self->file_size;\n\n memset(header, 0, sizeof(header));\n memcpy(header, KAS_MAGIC, 8);\n memcpy(header + 8, &version_major, 2);\n memcpy(header + 10, &version_minor, 2);\n memcpy(header + 12, &num_items, 4);\n memcpy(header + 16, &file_size, 8);\n /* Rest of header is reserved */\n if (fwrite(header, KAS_HEADER_SIZE, 1, self->file) != 1) {\n ret = KAS_ERR_IO;\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int KAS_WARN_UNUSED\nkastore_read_header(kastore_t *self)\n{\n int ret = 0;\n char header[KAS_HEADER_SIZE];\n uint16_t version_major, version_minor;\n uint32_t num_items;\n uint64_t file_size;\n size_t count;\n\n count = fread(header, 1, KAS_HEADER_SIZE, self->file);\n if (count == 0 && feof(self->file)) {\n ret = KAS_ERR_EOF;\n goto out;\n } else if (count != KAS_HEADER_SIZE) {\n ret = kastore_get_read_io_error(self);\n goto out;\n }\n if (strncmp(header, KAS_MAGIC, 8) != 0) {\n ret = KAS_ERR_BAD_FILE_FORMAT;\n goto out;\n }\n memcpy(&version_major, header + 8, 2);\n memcpy(&version_minor, header + 10, 2);\n memcpy(&num_items, header + 12, 4);\n memcpy(&file_size, header + 16, 8);\n self->file_version[0] = (int) version_major;\n self->file_version[1] = (int) version_minor;\n if (self->file_version[0] < KAS_FILE_VERSION_MAJOR) {\n ret = KAS_ERR_VERSION_TOO_OLD;\n goto out;\n } else if (self->file_version[0] > KAS_FILE_VERSION_MAJOR) {\n ret = KAS_ERR_VERSION_TOO_NEW;\n goto out;\n }\n self->num_items = num_items;\n self->file_size = (size_t) file_size;\n if (self->file_size < KAS_HEADER_SIZE) {\n ret = KAS_ERR_BAD_FILE_FORMAT;\n goto out;\n }\nout:\n return ret;\n}\n\n/* Compute the locations of the keys and arrays in the file. */\nstatic void\nkastore_pack_items(kastore_t *self)\n{\n size_t j, offset, remainder;\n\n /* Pack the keys */\n offset = KAS_HEADER_SIZE + self->num_items * KAS_ITEM_DESCRIPTOR_SIZE;\n for (j = 0; j < self->num_items; j++) {\n self->items[j].key_start = offset;\n offset += self->items[j].key_len;\n }\n /* Pack the arrays */\n for (j = 0; j < self->num_items; j++) {\n remainder = offset % KAS_ARRAY_ALIGN;\n if (remainder != 0) {\n offset += KAS_ARRAY_ALIGN - remainder;\n }\n self->items[j].array_start = offset;\n offset += self->items[j].array_len * type_size(self->items[j].type);\n }\n self->file_size = offset;\n}\n\nstatic int KAS_WARN_UNUSED\nkastore_write_descriptors(kastore_t *self)\n{\n int ret = 0;\n size_t j;\n uint8_t type;\n uint64_t key_start, key_len, array_start, array_len;\n char descriptor[KAS_ITEM_DESCRIPTOR_SIZE];\n\n for (j = 0; j < self->num_items; j++) {\n memset(descriptor, 0, KAS_ITEM_DESCRIPTOR_SIZE);\n type = (uint8_t) self->items[j].type;\n key_start = (uint64_t) self->items[j].key_start;\n key_len = (uint64_t) self->items[j].key_len;\n array_start = (uint64_t) self->items[j].array_start;\n array_len = (uint64_t) self->items[j].array_len;\n memcpy(descriptor, &type, 1);\n /* Bytes 1-8 are reserved */\n memcpy(descriptor + 8, &key_start, 8);\n memcpy(descriptor + 16, &key_len, 8);\n memcpy(descriptor + 24, &array_start, 8);\n memcpy(descriptor + 32, &array_len, 8);\n /* Rest of descriptor is reserved */\n if (fwrite(descriptor, sizeof(descriptor), 1, self->file) != 1) {\n ret = KAS_ERR_IO;\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int KAS_WARN_UNUSED\nkastore_read_descriptors(kastore_t *self)\n{\n int ret = KAS_ERR_BAD_FILE_FORMAT;\n size_t j;\n uint8_t type;\n uint64_t key_start, key_len, array_start, array_len;\n char *descriptor;\n size_t descriptor_offset, offset, remainder, size, count;\n char *read_buffer = NULL;\n\n size = self->num_items * KAS_ITEM_DESCRIPTOR_SIZE;\n if (size + KAS_HEADER_SIZE > self->file_size) {\n goto out;\n }\n read_buffer = (char *) malloc(size);\n if (read_buffer == NULL) {\n ret = KAS_ERR_NO_MEMORY;\n goto out;\n }\n count = fread(read_buffer, size, 1, self->file);\n if (count == 0) {\n ret = kastore_get_read_io_error(self);\n goto out;\n }\n\n descriptor_offset = 0;\n for (j = 0; j < self->num_items; j++) {\n descriptor = read_buffer + descriptor_offset;\n descriptor_offset += KAS_ITEM_DESCRIPTOR_SIZE;\n memcpy(&type, descriptor, 1);\n memcpy(&key_start, descriptor + 8, 8);\n memcpy(&key_len, descriptor + 16, 8);\n memcpy(&array_start, descriptor + 24, 8);\n memcpy(&array_len, descriptor + 32, 8);\n\n if (type >= KAS_NUM_TYPES) {\n ret = KAS_ERR_BAD_TYPE;\n goto out;\n }\n self->items[j].type = (int) type;\n if (key_start + key_len > self->file_size) {\n goto out;\n }\n self->items[j].key_start = (size_t) key_start;\n self->items[j].key_len = (size_t) key_len;\n if (array_start + array_len * type_size(type) > self->file_size) {\n goto out;\n }\n self->items[j].array_start = (size_t) array_start;\n self->items[j].array_len = (size_t) array_len;\n }\n\n /* Check the integrity of the key and array packing. Keys must\n * be packed sequentially starting immediately after the descriptors. */\n offset = KAS_HEADER_SIZE + self->num_items * KAS_ITEM_DESCRIPTOR_SIZE;\n for (j = 0; j < self->num_items; j++) {\n if (self->items[j].key_start != offset) {\n ret = KAS_ERR_BAD_FILE_FORMAT;\n goto out;\n }\n offset += self->items[j].key_len;\n }\n for (j = 0; j < self->num_items; j++) {\n /* Arrays are 8 byte aligned and adjacent */\n remainder = offset % KAS_ARRAY_ALIGN;\n if (remainder != 0) {\n offset += KAS_ARRAY_ALIGN - remainder;\n }\n if (self->items[j].array_start != offset) {\n ret = KAS_ERR_BAD_FILE_FORMAT;\n goto out;\n }\n offset += self->items[j].array_len * type_size(self->items[j].type);\n }\n if (offset != self->file_size) {\n ret = KAS_ERR_BAD_FILE_FORMAT;\n goto out;\n }\n ret = 0;\nout:\n kas_safe_free(read_buffer);\n return ret;\n}\n\nstatic int KAS_WARN_UNUSED\nkastore_write_data(kastore_t *self)\n{\n int ret = 0;\n size_t j, size, offset, padding;\n char pad[KAS_ARRAY_ALIGN] = { 0, 0, 0, 0, 0, 0, 0 };\n const void *write_array;\n\n offset = KAS_HEADER_SIZE + self->num_items * KAS_ITEM_DESCRIPTOR_SIZE;\n\n /* Write the keys. */\n for (j = 0; j < self->num_items; j++) {\n assert(offset == self->items[j].key_start);\n if (fwrite(self->items[j].key, self->items[j].key_len, 1, self->file) != 1) {\n ret = KAS_ERR_IO;\n goto out;\n }\n offset += self->items[j].key_len;\n }\n /* Write the arrays. */\n for (j = 0; j < self->num_items; j++) {\n padding = self->items[j].array_start - offset;\n assert(padding < KAS_ARRAY_ALIGN);\n if (padding > 0 && fwrite(pad, padding, 1, self->file) != 1) {\n ret = KAS_ERR_IO;\n goto out;\n }\n size = self->items[j].array_len * type_size(self->items[j].type);\n write_array = self->items[j].borrowed_array != NULL\n ? self->items[j].borrowed_array\n : self->items[j].array;\n assert(write_array != NULL);\n if (size > 0 && fwrite(write_array, size, 1, self->file) != 1) {\n ret = KAS_ERR_IO;\n goto out;\n }\n offset = self->items[j].array_start + size;\n }\nout:\n return ret;\n}\n\nstatic int KAS_WARN_UNUSED\nkastore_read_file(kastore_t *self)\n{\n int ret = 0;\n size_t count, size, offset, j;\n bool read_all = !!(self->flags & KAS_READ_ALL);\n\n offset = KAS_HEADER_SIZE + self->num_items * KAS_ITEM_DESCRIPTOR_SIZE;\n\n /* Read in up to the start of first array. This will contain all the keys. */\n size = self->items[0].array_start;\n\n assert(size > offset);\n size -= offset;\n\n self->key_read_buffer = (char *) malloc(size);\n if (self->key_read_buffer == NULL) {\n ret = KAS_ERR_NO_MEMORY;\n goto out;\n }\n count = fread(self->key_read_buffer, size, 1, self->file);\n if (count == 0) {\n ret = kastore_get_read_io_error(self);\n goto out;\n }\n /* Assign the pointers for the keys and arrays */\n for (j = 0; j < self->num_items; j++) {\n /* keys are already loaded in the read buffer */\n self->items[j].key = self->key_read_buffer + self->items[j].key_start - offset;\n if (read_all) {\n if (j == self->num_items - 1) {\n size = self->file_size - self->items[j].array_start;\n } else {\n size = self->items[j + 1].array_start - self->items[j].array_start;\n }\n self->items[j].array = (char *) malloc(size == 0 ? 1 : size);\n if (self->items[j].array == NULL) {\n ret = KAS_ERR_NO_MEMORY;\n goto out;\n }\n if (size > 0) {\n count = fread(self->items[j].array, size, 1, self->file);\n if (count == 0) {\n ret = kastore_get_read_io_error(self);\n goto out;\n }\n }\n }\n }\nout:\n return ret;\n}\n\nstatic int KAS_WARN_UNUSED\nkastore_read_item(kastore_t *self, kaitem_t *item)\n{\n int ret = 0;\n int err;\n size_t size = item->array_len * type_size(item->type);\n size_t count;\n\n item->array = malloc(size == 0 ? 1 : size);\n if (item->array == NULL) {\n ret = KAS_ERR_NO_MEMORY;\n goto out;\n }\n if (size > 0) {\n err = fseek(self->file, self->file_offset + (long) item->array_start, SEEK_SET);\n if (err != 0) {\n ret = KAS_ERR_IO;\n goto out;\n }\n count = fread(item->array, size, 1, self->file);\n if (count == 0) {\n ret = kastore_get_read_io_error(self);\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int KAS_WARN_UNUSED\nkastore_write_file(kastore_t *self)\n{\n int ret = 0;\n\n qsort(self->items, self->num_items, sizeof(kaitem_t), compare_items);\n kastore_pack_items(self);\n ret = kastore_write_header(self);\n if (ret != 0) {\n goto out;\n }\n ret = kastore_write_descriptors(self);\n if (ret != 0) {\n goto out;\n }\n ret = kastore_write_data(self);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int KAS_WARN_UNUSED\nkastore_read(kastore_t *self)\n{\n int ret = 0;\n\n if (!(self->flags & KAS_READ_ALL)) {\n /* Record the current file offset, in case this is a multi-store file,\n * so that we can seek to the correct location in kastore_read_item().\n */\n self->file_offset = ftell(self->file);\n if (self->file_offset == -1) {\n ret = KAS_ERR_IO;\n goto out;\n }\n }\n ret = kastore_read_header(self);\n if (ret != 0) {\n goto out;\n }\n if (self->num_items > 0) {\n self->items = (kaitem_t *) calloc(self->num_items, sizeof(*self->items));\n if (self->items == NULL) {\n ret = KAS_ERR_NO_MEMORY;\n goto out;\n }\n ret = kastore_read_descriptors(self);\n if (ret != 0) {\n goto out;\n }\n ret = kastore_read_file(self);\n if (ret != 0) {\n goto out;\n }\n } else if (self->file_size != KAS_HEADER_SIZE) {\n ret = KAS_ERR_BAD_FILE_FORMAT;\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int KAS_WARN_UNUSED\nkastore_insert_all(kastore_t *self, kastore_t *other)\n{\n size_t j;\n int ret = 0;\n kaitem_t item;\n\n for (j = 0; j < other->num_items; j++) {\n item = other->items[j];\n ret = kastore_put(\n self, item.key, item.key_len, item.array, item.array_len, item.type, 0);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nint KAS_WARN_UNUSED\nkastore_open(kastore_t *self, const char *filename, const char *mode, int flags)\n{\n int ret = 0;\n const char *file_mode;\n bool appending = false;\n kastore_t tmp;\n FILE *file;\n int err;\n\n memset(self, 0, sizeof(*self));\n memset(&tmp, 0, sizeof(tmp));\n if (strlen(mode) != 1) {\n ret = KAS_ERR_BAD_MODE;\n goto out;\n }\n if (strncmp(mode, \"r\", 1) == 0) {\n file_mode = \"rb\";\n } else if (strncmp(mode, \"w\", 1) == 0) {\n file_mode = \"wb\";\n } else if (strncmp(mode, \"a\", 1) == 0) {\n mode = \"w\";\n file_mode = \"wb\";\n appending = true;\n } else {\n ret = KAS_ERR_BAD_MODE;\n goto out;\n }\n if (appending) {\n ret = kastore_open(&tmp, filename, \"r\", KAS_READ_ALL);\n if (ret != 0) {\n goto out;\n }\n /* tmp will now have read all of the data into memory. We can now\n * close its file. We have to do this for Windows. */\n err = fclose(tmp.file);\n tmp.file = NULL;\n if (err != 0) {\n ret = KAS_ERR_IO;\n goto out;\n }\n }\n file = fopen(filename, file_mode);\n if (file == NULL) {\n ret = KAS_ERR_IO;\n goto out;\n }\n ret = kastore_openf(self, file, mode, flags);\n if (ret != 0) {\n (void) fclose(file);\n } else {\n self->flags |= OWN_FILE;\n if (appending) {\n ret = kastore_insert_all(self, &tmp);\n }\n }\nout:\n if (appending) {\n kastore_close(&tmp);\n }\n return ret;\n}\n\nint KAS_WARN_UNUSED\nkastore_openf(kastore_t *self, FILE *file, const char *mode, int flags)\n{\n int ret = 0;\n\n memset(self, 0, sizeof(*self));\n if (strlen(mode) != 1) {\n ret = KAS_ERR_BAD_MODE;\n goto out;\n }\n if (strncmp(mode, \"r\", 1) == 0) {\n self->mode = KAS_READ;\n } else if (strncmp(mode, \"w\", 1) == 0) {\n self->mode = KAS_WRITE;\n } else {\n ret = KAS_ERR_BAD_MODE;\n goto out;\n }\n\n if (flags > (KAS_READ_ALL | KAS_GET_TAKES_OWNERSHIP) || flags < 0) {\n ret = KAS_ERR_BAD_FLAGS;\n goto out;\n }\n\n self->flags = flags;\n self->file = file;\n if (self->mode == KAS_READ) {\n ret = kastore_read(self);\n }\nout:\n return ret;\n}\n\nint KAS_WARN_UNUSED\nkastore_close(kastore_t *self)\n{\n int ret = 0;\n int err;\n size_t j;\n\n if (self->mode == KAS_WRITE) {\n if (self->file != NULL) {\n ret = kastore_write_file(self);\n if (ret != 0) {\n /* Ignore errors on close now */\n if (self->flags & OWN_FILE) {\n fclose(self->file);\n }\n self->file = NULL;\n }\n }\n if (self->items != NULL) {\n /* We only alloc memory for the keys and arrays in write mode */\n for (j = 0; j < self->num_items; j++) {\n kas_safe_free(self->items[j].key);\n kas_safe_free(self->items[j].array);\n }\n }\n } else {\n kas_safe_free(self->key_read_buffer);\n if (self->items != NULL) {\n for (j = 0; j < self->num_items; j++) {\n kas_safe_free(self->items[j].array);\n }\n }\n }\n kas_safe_free(self->items);\n if (self->file != NULL && (self->flags & OWN_FILE)) {\n err = fclose(self->file);\n if (err != 0) {\n ret = KAS_ERR_IO;\n }\n }\n memset(self, 0, sizeof(*self));\n return ret;\n}\n\nstatic int\nkastore_find_item(kastore_t *self, const char *key, size_t key_len, kaitem_t **item)\n{\n int ret = KAS_ERR_KEY_NOT_FOUND;\n kaitem_t search;\n search.key = (char *) malloc(key_len);\n search.key_len = key_len;\n\n if (self->mode != KAS_READ) {\n ret = KAS_ERR_ILLEGAL_OPERATION;\n goto out;\n }\n if (search.key == NULL) {\n ret = KAS_ERR_NO_MEMORY;\n goto out;\n }\n memcpy(search.key, key, key_len);\n *item = bsearch(\n &search, self->items, self->num_items, sizeof(kaitem_t), compare_items);\n if (*item == NULL) {\n goto out;\n }\n ret = 0;\nout:\n kas_safe_free(search.key);\n return ret;\n}\n\nint KAS_WARN_UNUSED\nkastore_contains(kastore_t *self, const char *key, size_t key_len)\n{\n kaitem_t *item;\n int ret = kastore_find_item(self, key, key_len, &item);\n if (ret == 0) {\n ret = 1;\n } else if (ret == KAS_ERR_KEY_NOT_FOUND) {\n ret = 0;\n }\n return ret;\n}\n\nint KAS_WARN_UNUSED\nkastore_containss(kastore_t *self, const char *key)\n{\n return kastore_contains(self, key, strlen(key));\n}\n\nint KAS_WARN_UNUSED\nkastore_get(kastore_t *self, const char *key, size_t key_len, void **array,\n size_t *array_len, int *type)\n{\n kaitem_t *item;\n int ret = kastore_find_item(self, key, key_len, &item);\n if (ret != 0) {\n goto out;\n }\n if (item->array == NULL) {\n ret = kastore_read_item(self, item);\n if (ret != 0) {\n goto out;\n }\n }\n *array = item->array;\n *array_len = item->array_len;\n *type = item->type;\n if (self->flags & KAS_GET_TAKES_OWNERSHIP) {\n item->array = NULL;\n }\n ret = 0;\nout:\n return ret;\n}\n\nint KAS_WARN_UNUSED\nkastore_gets(\n kastore_t *self, const char *key, void **array, size_t *array_len, int *type)\n{\n return kastore_get(self, key, strlen(key), array, array_len, type);\n}\n\nstatic int KAS_WARN_UNUSED\nkastore_gets_type(\n kastore_t *self, const char *key, void **array, size_t *array_len, int type)\n{\n int loaded_type = -1;\n int ret;\n\n ret = kastore_get(self, key, strlen(key), array, array_len, &loaded_type);\n if (ret != 0) {\n goto out;\n }\n if (type != loaded_type) {\n ret = KAS_ERR_TYPE_MISMATCH;\n goto out;\n }\nout:\n return ret;\n}\n\nint KAS_WARN_UNUSED\nkastore_gets_int8(kastore_t *self, const char *key, int8_t **array, size_t *array_len)\n{\n return kastore_gets_type(self, key, (void **) array, array_len, KAS_INT8);\n}\n\nint KAS_WARN_UNUSED\nkastore_gets_uint8(kastore_t *self, const char *key, uint8_t **array, size_t *array_len)\n{\n return kastore_gets_type(self, key, (void **) array, array_len, KAS_UINT8);\n}\n\nint KAS_WARN_UNUSED\nkastore_gets_int16(kastore_t *self, const char *key, int16_t **array, size_t *array_len)\n{\n return kastore_gets_type(self, key, (void **) array, array_len, KAS_INT16);\n}\n\nint KAS_WARN_UNUSED\nkastore_gets_uint16(\n kastore_t *self, const char *key, uint16_t **array, size_t *array_len)\n{\n return kastore_gets_type(self, key, (void **) array, array_len, KAS_UINT16);\n}\n\nint KAS_WARN_UNUSED\nkastore_gets_int32(kastore_t *self, const char *key, int32_t **array, size_t *array_len)\n{\n return kastore_gets_type(self, key, (void **) array, array_len, KAS_INT32);\n}\n\nint KAS_WARN_UNUSED\nkastore_gets_uint32(\n kastore_t *self, const char *key, uint32_t **array, size_t *array_len)\n{\n return kastore_gets_type(self, key, (void **) array, array_len, KAS_UINT32);\n}\n\nint KAS_WARN_UNUSED\nkastore_gets_int64(kastore_t *self, const char *key, int64_t **array, size_t *array_len)\n{\n return kastore_gets_type(self, key, (void **) array, array_len, KAS_INT64);\n}\n\nint KAS_WARN_UNUSED\nkastore_gets_uint64(\n kastore_t *self, const char *key, uint64_t **array, size_t *array_len)\n{\n return kastore_gets_type(self, key, (void **) array, array_len, KAS_UINT64);\n}\n\nint KAS_WARN_UNUSED\nkastore_gets_float32(kastore_t *self, const char *key, float **array, size_t *array_len)\n{\n return kastore_gets_type(self, key, (void **) array, array_len, KAS_FLOAT32);\n}\n\nint KAS_WARN_UNUSED\nkastore_gets_float64(kastore_t *self, const char *key, double **array, size_t *array_len)\n{\n return kastore_gets_type(self, key, (void **) array, array_len, KAS_FLOAT64);\n}\n\nstatic int KAS_WARN_UNUSED\nkastore_put_item(kastore_t *self, kaitem_t **ret_item, const char *key, size_t key_len,\n int type, int KAS_UNUSED(flags))\n{\n int ret = 0;\n kaitem_t *new_item;\n kaitem_t *p;\n size_t j;\n\n if (self->mode != KAS_WRITE) {\n ret = KAS_ERR_ILLEGAL_OPERATION;\n goto out;\n }\n if (type < 0 || type >= KAS_NUM_TYPES) {\n ret = KAS_ERR_BAD_TYPE;\n goto out;\n }\n if (key_len == 0) {\n ret = KAS_ERR_EMPTY_KEY;\n goto out;\n }\n /* This isn't terribly efficient, but we're not expecting large\n * numbers of items. */\n p = (kaitem_t *) realloc(self->items, (self->num_items + 1) * sizeof(*self->items));\n if (p == NULL) {\n ret = KAS_ERR_NO_MEMORY;\n goto out;\n }\n self->items = p;\n new_item = self->items + self->num_items;\n\n memset(new_item, 0, sizeof(*new_item));\n new_item->type = type;\n new_item->key_len = key_len;\n new_item->key = (char *) malloc(key_len);\n if (new_item->key == NULL) {\n kas_safe_free(new_item->key);\n ret = KAS_ERR_NO_MEMORY;\n goto out;\n }\n self->num_items++;\n memcpy(new_item->key, key, key_len);\n\n /* Check if this key is already in here. OK, this is a quadratic time\n * algorithm, but we're not expecting to have lots of items (< 100). In\n * this case, the simple algorithm is probably better. If/when we ever\n * deal with more items than this, then we will need a better algorithm.\n */\n for (j = 0; j < self->num_items - 1; j++) {\n if (compare_items(new_item, self->items + j) == 0) {\n /* Free the key memory and remove this item */\n self->num_items--;\n kas_safe_free(new_item->key);\n ret = KAS_ERR_DUPLICATE_KEY;\n goto out;\n }\n }\n *ret_item = new_item;\nout:\n return ret;\n}\n\nstatic int KAS_WARN_UNUSED\nkastore_bput(kastore_t *self, const char *key, size_t key_len, const void *array,\n size_t array_len, int type, int flags)\n{\n int ret = 0;\n kaitem_t *item;\n ret = kastore_put_item(self, &item, key, key_len, type, flags);\n if (ret != 0) {\n goto out;\n }\n if (array == NULL) {\n /* Both can't be null, so assign a dummy array */\n item->array = malloc(1);\n } else {\n item->borrowed_array = array;\n }\n item->borrowed_array = array;\n item->array_len = array_len;\nout:\n return ret;\n}\n\nint KAS_WARN_UNUSED\nkastore_put(kastore_t *self, const char *key, size_t key_len, const void *array,\n size_t array_len, int type, int flags)\n{\n int ret;\n size_t array_size;\n void *array_copy = NULL;\n\n if (flags != KAS_BORROWS_ARRAY && flags != 0) {\n ret = KAS_ERR_BAD_FLAGS;\n goto out;\n }\n\n if (type < 0 || type >= KAS_NUM_TYPES) {\n ret = KAS_ERR_BAD_TYPE;\n goto out;\n }\n if (flags & KAS_BORROWS_ARRAY) {\n ret = kastore_bput(self, key, key_len, array, array_len, type, flags);\n } else {\n array_size = type_size(type) * array_len;\n array_copy = malloc(array_size == 0 ? 1 : array_size);\n if (array_copy == NULL) {\n ret = KAS_ERR_NO_MEMORY;\n goto out;\n }\n memcpy(array_copy, array, array_size);\n ret = kastore_oput(self, key, key_len, array_copy, array_len, type, flags);\n if (ret == 0) {\n /* Kastore has taken ownership of the array, so we don't need to free it */\n array_copy = NULL;\n }\n }\nout:\n kas_safe_free(array_copy);\n return ret;\n}\n\nint KAS_WARN_UNUSED\nkastore_oput(kastore_t *self, const char *key, size_t key_len, void *array,\n size_t array_len, int type, int flags)\n{\n int ret = 0;\n kaitem_t *item;\n\n if (flags != 0) {\n ret = KAS_ERR_BAD_FLAGS;\n goto out;\n }\n\n ret = kastore_put_item(self, &item, key, key_len, type, flags);\n if (ret != 0) {\n goto out;\n }\n item->array = array;\n item->array_len = array_len;\nout:\n return ret;\n}\n\nint KAS_WARN_UNUSED\nkastore_puts(kastore_t *self, const char *key, const void *array, size_t array_len,\n int type, int flags)\n{\n return kastore_put(self, key, strlen(key), array, array_len, type, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_puts_int8(\n kastore_t *self, const char *key, const int8_t *array, size_t array_len, int flags)\n{\n return kastore_puts(self, key, (const void *) array, array_len, KAS_INT8, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_puts_uint8(\n kastore_t *self, const char *key, const uint8_t *array, size_t array_len, int flags)\n{\n return kastore_puts(self, key, (const void *) array, array_len, KAS_UINT8, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_puts_int16(\n kastore_t *self, const char *key, const int16_t *array, size_t array_len, int flags)\n{\n return kastore_puts(self, key, (const void *) array, array_len, KAS_INT16, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_puts_uint16(\n kastore_t *self, const char *key, const uint16_t *array, size_t array_len, int flags)\n{\n return kastore_puts(self, key, (const void *) array, array_len, KAS_UINT16, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_puts_int32(\n kastore_t *self, const char *key, const int32_t *array, size_t array_len, int flags)\n{\n return kastore_puts(self, key, (const void *) array, array_len, KAS_INT32, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_puts_uint32(\n kastore_t *self, const char *key, const uint32_t *array, size_t array_len, int flags)\n{\n return kastore_puts(self, key, (const void *) array, array_len, KAS_UINT32, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_puts_int64(\n kastore_t *self, const char *key, const int64_t *array, size_t array_len, int flags)\n{\n return kastore_puts(self, key, (const void *) array, array_len, KAS_INT64, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_puts_uint64(\n kastore_t *self, const char *key, const uint64_t *array, size_t array_len, int flags)\n{\n return kastore_puts(self, key, (const void *) array, array_len, KAS_UINT64, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_puts_float32(\n kastore_t *self, const char *key, const float *array, size_t array_len, int flags)\n{\n return kastore_puts(self, key, (const void *) array, array_len, KAS_FLOAT32, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_puts_float64(\n kastore_t *self, const char *key, const double *array, size_t array_len, int flags)\n{\n return kastore_puts(self, key, (const void *) array, array_len, KAS_FLOAT64, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_oputs(\n kastore_t *self, const char *key, void *array, size_t array_len, int type, int flags)\n{\n return kastore_oput(self, key, strlen(key), array, array_len, type, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_oputs_int8(\n kastore_t *self, const char *key, int8_t *array, size_t array_len, int flags)\n{\n return kastore_oputs(self, key, (void *) array, array_len, KAS_INT8, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_oputs_uint8(\n kastore_t *self, const char *key, uint8_t *array, size_t array_len, int flags)\n{\n return kastore_oputs(self, key, (void *) array, array_len, KAS_UINT8, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_oputs_int16(\n kastore_t *self, const char *key, int16_t *array, size_t array_len, int flags)\n{\n return kastore_oputs(self, key, (void *) array, array_len, KAS_INT16, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_oputs_uint16(\n kastore_t *self, const char *key, uint16_t *array, size_t array_len, int flags)\n{\n return kastore_oputs(self, key, (void *) array, array_len, KAS_UINT16, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_oputs_int32(\n kastore_t *self, const char *key, int32_t *array, size_t array_len, int flags)\n{\n return kastore_oputs(self, key, (void *) array, array_len, KAS_INT32, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_oputs_uint32(\n kastore_t *self, const char *key, uint32_t *array, size_t array_len, int flags)\n{\n return kastore_oputs(self, key, (void *) array, array_len, KAS_UINT32, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_oputs_int64(\n kastore_t *self, const char *key, int64_t *array, size_t array_len, int flags)\n{\n return kastore_oputs(self, key, (void *) array, array_len, KAS_INT64, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_oputs_uint64(\n kastore_t *self, const char *key, uint64_t *array, size_t array_len, int flags)\n{\n return kastore_oputs(self, key, (void *) array, array_len, KAS_UINT64, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_oputs_float32(\n kastore_t *self, const char *key, float *array, size_t array_len, int flags)\n{\n return kastore_oputs(self, key, (void *) array, array_len, KAS_FLOAT32, flags);\n}\n\nint KAS_WARN_UNUSED\nkastore_oputs_float64(\n kastore_t *self, const char *key, double *array, size_t array_len, int flags)\n{\n return kastore_oputs(self, key, (void *) array, array_len, KAS_FLOAT64, flags);\n}\n\nvoid\nkastore_print_state(kastore_t *self, FILE *out)\n{\n kaitem_t *item;\n size_t j;\n\n fprintf(out, \"============================\\n\");\n fprintf(out, \"kastore state\\n\");\n fprintf(out, \"file_version = %d.%d\\n\", self->file_version[0], self->file_version[1]);\n fprintf(out, \"mode = %d\\n\", self->mode);\n fprintf(out, \"flags = %d\\n\", self->flags);\n fprintf(out, \"num_items = %zu\\n\", self->num_items);\n fprintf(out, \"file_size = %zu\\n\", self->file_size);\n fprintf(out, \"own_file = %d\\n\", !!(self->flags & OWN_FILE));\n fprintf(out, \"file = '%p'\\n\", (void *) self->file);\n fprintf(out, \"============================\\n\");\n for (j = 0; j < self->num_items; j++) {\n item = self->items + j;\n fprintf(out,\n \"%.*s: type=%d, key_start=%zu, key_len=%zu, key=%p, \"\n \"array_start=%zu, array_len=%zu, array=%p\\n\",\n (int) item->key_len, item->key, item->type, item->key_start, item->key_len,\n (void *) item->key, item->array_start, item->array_len,\n (void *) item->array);\n }\n fprintf(out, \"============================\\n\");\n}\n"
},
{
"path": "c/subprojects/kastore/kastore.h",
"content": "/**\n * @file kastore.h\n * @brief Public API for kastore.\n *\n * This is the API documentation for kastore.\n */\n#ifndef KASTORE_H\n#define KASTORE_H\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#ifdef __GNUC__\n#define KAS_WARN_UNUSED __attribute__((warn_unused_result))\n#define KAS_UNUSED(x) KAS_UNUSED_##x __attribute__((__unused__))\n#else\n#define KAS_WARN_UNUSED\n#define KAS_UNUSED(x) KAS_UNUSED_##x\n#endif\n\n#include \n#include \n#include \n#include \n\n/**\n@defgroup ERROR_GROUP Error return values.\n@{\n*/\n// clang-format off\n/**\nGeneric error thrown when no other message can be generated.\n*/\n#define KAS_ERR_GENERIC -1\n/**\nAn error occured during IO.\n*/\n#define KAS_ERR_IO -2\n/**\nAn unrecognised mode string was passed to open().\n*/\n#define KAS_ERR_BAD_MODE -3\n/**\nOut-of-memory condition.\n*/\n#define KAS_ERR_NO_MEMORY -4\n/**\nAttempt to read an unknown file format.\n*/\n#define KAS_ERR_BAD_FILE_FORMAT -5\n/**\nThe file is in kastore format, but the version is too old for this\nversion of the library to read.\n*/\n#define KAS_ERR_VERSION_TOO_OLD -6\n/**\nThe file is in kastore format, but the version is too new for this\nversion of the library to read.\n*/\n#define KAS_ERR_VERSION_TOO_NEW -7\n/**\nAn unknown type key was specified.\n*/\n#define KAS_ERR_BAD_TYPE -8\n/**\nA zero-length key was specified.\n*/\n#define KAS_ERR_EMPTY_KEY -9\n/**\nA duplicate key was specified.\n*/\n#define KAS_ERR_DUPLICATE_KEY -10\n/**\nThe requested key does not exist in the store.\n*/\n#define KAS_ERR_KEY_NOT_FOUND -11\n/**\nThe requestion function cannot be called in the current mode.\n*/\n#define KAS_ERR_ILLEGAL_OPERATION -12\n/**\nThe requested type does not match the type of the stored values.\n*/\n#define KAS_ERR_TYPE_MISMATCH -13\n/**\nEnd of file was reached while reading data.\n*/\n#define KAS_ERR_EOF -14\n/**\nUnknown flags were provided to open.\n*/\n#define KAS_ERR_BAD_FLAGS -15\n/** @} */\n\n/* Flags for open */\n#define KAS_READ_ALL (1 << 0)\n#define KAS_GET_TAKES_OWNERSHIP (1 << 1)\n\n/* Flags for put */\n#define KAS_BORROWS_ARRAY (1 << 8)\n\n\n/**\n@defgroup TYPE_GROUP Data types.\n@{\n*/\n#define KAS_INT8 0\n#define KAS_UINT8 1\n#define KAS_INT16 2\n#define KAS_UINT16 3\n#define KAS_INT32 4\n#define KAS_UINT32 5\n#define KAS_INT64 6\n#define KAS_UINT64 7\n#define KAS_FLOAT32 8\n#define KAS_FLOAT64 9\n/** @} */\n\n#define KAS_NUM_TYPES 10\n\n#define KAS_READ 1\n#define KAS_WRITE 2\n\n/**\n@defgroup FILE_VERSION_GROUP File version macros.\n@{\n*/\n/**\nThe file version major number. Incremented when any breaking changes are made\nto the file format.\n*/\n#define KAS_FILE_VERSION_MAJOR 1\n/**\nThe file version minor number. Incremented when non-breaking backward-compatible\nchanges are made to the file format.\n*/\n#define KAS_FILE_VERSION_MINOR 0\n/** @} */\n\n/**\n@defgroup API_VERSION_GROUP API version macros.\n@{\n*/\n/**\nThe library major version. Incremented when breaking changes to the API or ABI are\nintroduced. This includes any changes to the signatures of functions and the\nsizes and types of externally visible structs.\n*/\n#define KAS_VERSION_MAJOR 2\n/**\nThe library minor version. Incremented when non-breaking backward-compatible changes\nto the API or ABI are introduced, i.e., the addition of a new function.\n*/\n#define KAS_VERSION_MINOR 1\n/**\nThe library patch version. Incremented when any changes not relevant to the\nto the API or ABI are introduced, i.e., internal refactors of bugfixes.\n*/\n#define KAS_VERSION_PATCH 2\n/** @} */\n\n#define KAS_HEADER_SIZE 64\n#define KAS_ITEM_DESCRIPTOR_SIZE 64\n#define KAS_MAGIC \"\\211KAS\\r\\n\\032\\n\"\n#define KAS_ARRAY_ALIGN 8\n// clang-format on\n\n#ifndef KAS_BUG_ASSERT_MESSAGE\n#define KAS_BUG_ASSERT_MESSAGE \\\n \"If you are using kastore directly please open an issue on\" \\\n \" GitHub, ideally with a reproducible example.\" \\\n \" (https://github.com/tskit-dev/kastore/issues) If you are\" \\\n \" using software that uses kastore, please report an issue\" \\\n \" to that software's issue tracker, at least initially.\"\n#endif\n\n/**\nWe often wish to assert a condition that is unexpected, but using the normal `assert`\nmeans compiling without NDEBUG. This macro still asserts when NDEBUG is defined.\n*/\n#define kas_bug_assert(condition) \\\n do { \\\n if (!(condition)) { \\\n fprintf(stderr, \"Bug detected in %s at line %d. %s\\n\", __FILE__, __LINE__, \\\n KAS_BUG_ASSERT_MESSAGE); \\\n abort(); \\\n } \\\n } while (0)\n\ntypedef struct {\n int type;\n size_t key_len;\n size_t array_len;\n char *key;\n /* Used when KAS_BORROWS_ARRAY is set */\n const void *borrowed_array;\n void *array;\n size_t key_start;\n size_t array_start;\n} kaitem_t;\n\n/**\n@brief A file-backed store of key-array values.\n*/\ntypedef struct {\n int flags;\n int mode;\n int file_version[2];\n size_t num_items;\n kaitem_t *items;\n FILE *file;\n size_t file_size;\n long file_offset;\n char *key_read_buffer;\n} kastore_t;\n\n/**\n@brief Library version information.\n*/\ntypedef struct {\n /** @brief The major version number. */\n int major;\n /** @brief The minor version number. */\n int minor;\n /** @brief The patch version number. */\n int patch;\n} kas_version_t;\n\n/**\n@brief Open a store from a given file in read (\"r\"), write (\"w\") or\nappend (\"a\") mode.\n\n@rst\nIn read mode, a store can be queried using the :ref:`get functions\n` and any attempts to write to the store will return an error.\nIn write and append mode, the store can written to using the :ref:`put\nfunctions ` and any attempt to read will return an error.\n\nAfter :c:func:`kastore_open` has been called on a particular store,\n:c:func:`kastore_close` must be called to avoid leaking memory. This must also\nbe done when :c:func:`kastore_open` returns an error.\n\nWhen opened in read-mode, the default is to read key/array values from file\non demand. This is useful when a subset of the data is required and we don't\nwish to read the entire file. If the entire file is to be read, the\n``KAS_READ_ALL`` flag may be specified to improve performance.\n\n**Flags**\n\nKAS_READ_ALL\n If this option is specified, read the entire file at\n open time. This will give slightly better performance as the file can\n be read sequentially in a single pass.\n\nKAS_GET_TAKES_OWNERSHIP\n If this option is specified, all ``get`` operations will transfer\n ownership of the array to the caller. ``kastore`` will not ``free``\n the array memory and this is the responsibility of the caller.\n If ``get`` is called on the same key multiple times, a new buffer will be\n returned each time. Note that second and subsequent ``get`` calls\n on a given key will result in ``seek`` operations even when the\n KAS_READ_ALL flag is set, and will therefore fail on unseekable\n streams.\n\n@endrst\n\n@param self A pointer to a kastore object.\n@param filename The file path to open.\n@param mode The open mode: can be read (\"r\"), write (\"w\") or append (\"a\").\n@param flags The open flags.\n@return Return 0 on success or a negative value on failure.\n*/\nint kastore_open(kastore_t *self, const char *filename, const char *mode, int flags);\n\n/**\n@brief Open a store from a given FILE pointer.\n\n@rst\nBehaviour, mode and flags follow that of :c:func:`kastore_open`,\nexcept append mode is not supported.\nThe ``file`` argument must be opened in an appropriate mode (e.g. \"r\"\nfor a kastore in \"r\" mode). Files open with other modes will result\nin KAS_ERR_IO being returned when read/write operations are attempted.\n\nThe FILE will not be closed when :c:func:`kastore_close` is called.\nIf the KAS_READ_ALL flag is supplied, no ``seek`` operations will be\nperformed on the FILE and so streams such as stdin, FIFOs etc are\nsupported. The FILE pointer will be positioned exactly at the end\nof the kastore encoded bytes once reading is completed, and reading\nmultiple stores from the same FILE sequentially is fully supported.\n@endrst\n\n@param self A pointer to a kastore object.\n@param file The FILE* to read/write the store from/to.\n@param mode The open mode: can be read (\"r\") or write (\"w\").\n@param flags The open flags.\n@return Return 0 on success or a negative value on failure.\n*/\nint kastore_openf(kastore_t *self, FILE *file, const char *mode, int flags);\n\n/**\n@brief Close an opened store, freeing all resources.\n\nAny store that has been opened must be closed to avoid memory leaks\n(including cases in which errors have occured). It is not an error to\ncall ``kastore_close`` multiple times on the same object, but\n``kastore_open`` must be called before ``kastore_close``.\n\n@param self A pointer to a kastore object.\n@return Return 0 on success or a negative value on failure.\n*/\nint kastore_close(kastore_t *self);\n\n/**\n@brief Return 1 if the store contains the specified key and 0 if it does not.\n\n@rst\nQueries the store for the specified key and returns 1 if it exists. If the\nkey does not exist, 0 is returned. If an error occurs (for example, if querying\nthe store while it is in write-mode), a negative value is returned.\n\nFor keys that are standard NULL terminated strings, the :c:func:`kastore_containss`\nfunction may be more convenient.\n@endrst\n\n@param self A pointer to a kastore object.\n@param key The key.\n@param key_len The length of the key.\n@return Return 1 if the key is present and 0 if it does not. If an error occurs,\n return a negative value.\n*/\nint kastore_contains(kastore_t *self, const char *key, size_t key_len);\n\n/**\n@brief Return 1 if the store contains the specified NULL terminated key\nand 0 if it does not.\n\n@rst\nQueries the store for the specified key, which must be a NULL terminated string,\nand returns 1 if it exists. If the\nkey does not exist, 0 is returned. If an error occurs (for example, if querying\nthe store while it is in write-mode), a negative value is returned.\nthe array in the specified destination pointers.\n@endrst\n\n@param self A pointer to a kastore object.\n@param key The key.\n@return Return 1 if the key is present and 0 if it does not. If an error occurs,\n return a negative value.\n*/\nint kastore_containss(kastore_t *self, const char *key);\n\n/**\n@brief Get the array for the specified key.\n\n@rst\nQueries the store for the specified key and stores pointers to the memory for\nthe corresponding array, the number of elements in this array and the type of\nthe array in the specified destination pointers. This is the most general form\nof ``get`` query in kastore, as non NULL-terminated strings can be used as\nkeys and the resulting array is returned in a generic pointer. When standard C\nstrings are used as keys and the type of the array is known, it is more\nconvenient to use the :ref:`typed variants ` of this function.\n\nThe returned array points to memory that is internally managed by the store\nand must not be freed or modified. The pointer is guaranteed to be valid\nuntil :c:func:`kastore_close` is called.\n@endrst\n\n@param self A pointer to a kastore object.\n@param key The key.\n@param key_len The length of the key.\n@param array The destination pointer for the array.\n@param array_len The destination pointer for the number of elements\nin the array.\n@param type The destination pointer for the type code of the array.\n@return Return 0 on success or a negative value on failure.\n*/\nint kastore_get(kastore_t *self, const char *key, size_t key_len, void **array,\n size_t *array_len, int *type);\n\n/**\n@brief Get the array for the specified NULL-terminated key.\n\n@rst\nAs for :c:func:`kastore_get()` except the key is a NULL-terminated string.\n@endrst\n\n@param self A pointer to a kastore object.\n@param key The key.\n@param array The destination pointer for the array.\n@param array_len The destination pointer for the number of elements\nin the array.\n@param type The destination pointer for the type code of the array.\n@return Return 0 on success or a negative value on failure.\n*/\nint kastore_gets(\n kastore_t *self, const char *key, void **array, size_t *array_len, int *type);\n\n/**\n@defgroup TYPED_GETS_GROUP Typed get functions.\n@{\n*/\n\nint kastore_gets_int8(\n kastore_t *self, const char *key, int8_t **array, size_t *array_len);\nint kastore_gets_uint8(\n kastore_t *self, const char *key, uint8_t **array, size_t *array_len);\nint kastore_gets_int16(\n kastore_t *self, const char *key, int16_t **array, size_t *array_len);\nint kastore_gets_uint16(\n kastore_t *self, const char *key, uint16_t **array, size_t *array_len);\nint kastore_gets_int32(\n kastore_t *self, const char *key, int32_t **array, size_t *array_len);\nint kastore_gets_uint32(\n kastore_t *self, const char *key, uint32_t **array, size_t *array_len);\nint kastore_gets_int64(\n kastore_t *self, const char *key, int64_t **array, size_t *array_len);\nint kastore_gets_uint64(\n kastore_t *self, const char *key, uint64_t **array, size_t *array_len);\nint kastore_gets_float32(\n kastore_t *self, const char *key, float **array, size_t *array_len);\nint kastore_gets_float64(\n kastore_t *self, const char *key, double **array, size_t *array_len);\n\n/** @} */\n\n/**\n@brief Insert the specified key-array pair into the store.\n\n@rst\nA key with the specified length is inserted into the store and associated with\nan array of the specified type and number of elements. The contents of the\nspecified key and array are copied unless the KAS_BORROWS_ARRAY flag is specified.\nIf KAS_BORROWS_ARRAY is specified the array buffer must persist until the\nkastore is closed.\nKeys can be any sequence of bytes but must be at least one byte long and be\nunique. There is no restriction on the contents of arrays. This is the most\ngeneral form of ``put`` operation in kastore; when the type of the array\nis known and the keys are standard C strings, it is usually more convenient\nto use the :ref:`typed variants ` of this function.\n@endrst\n\n@param self A pointer to a kastore object.\n@param key The key.\n@param key_len The length of the key.\n@param array The array.\n@param array_len The number of elements in the array.\n@param type The type of the array.\n@param flags The insertion flags, only KAS_BORROWS_ARRAY or 0 is a valid.\n@return Return 0 on success or a negative value on failure.\n*/\nint kastore_put(kastore_t *self, const char *key, size_t key_len, const void *array,\n size_t array_len, int type, int flags);\n/**\n@brief Insert the specified NULL terminated key and array pair into the store.\n\n@rst\nAs for :c:func:`kastore_put` except the key must be NULL-terminated C string.\n@endrst\n\n@param self A pointer to a kastore object.\n@param key The key.\n@param array The array.\n@param array_len The number of elements in the array.\n@param type The type of the array.\n@param flags The insertion flags, only KAS_BORROWS_ARRAY or 0 is a valid.\n@return Return 0 on success or a negative value on failure.\n*/\nint kastore_puts(kastore_t *self, const char *key, const void *array, size_t array_len,\n int type, int flags);\n\n/**\n @defgroup TYPED_PUTS_GROUP Typed put functions.\n @{\n */\n\nint kastore_puts_int8(\n kastore_t *self, const char *key, const int8_t *array, size_t array_len, int flags);\nint kastore_puts_uint8(\n kastore_t *self, const char *key, const uint8_t *array, size_t array_len, int flags);\nint kastore_puts_int16(\n kastore_t *self, const char *key, const int16_t *array, size_t array_len, int flags);\nint kastore_puts_uint16(kastore_t *self, const char *key, const uint16_t *array,\n size_t array_len, int flags);\nint kastore_puts_int32(\n kastore_t *self, const char *key, const int32_t *array, size_t array_len, int flags);\nint kastore_puts_uint32(kastore_t *self, const char *key, const uint32_t *array,\n size_t array_len, int flags);\nint kastore_puts_int64(\n kastore_t *self, const char *key, const int64_t *array, size_t array_len, int flags);\nint kastore_puts_uint64(kastore_t *self, const char *key, const uint64_t *array,\n size_t array_len, int flags);\nint kastore_puts_float32(\n kastore_t *self, const char *key, const float *array, size_t array_len, int flags);\nint kastore_puts_float64(\n kastore_t *self, const char *key, const double *array, size_t array_len, int flags);\n\n/** @} */\n\n/**\n@brief Insert the specified key-array pair into the store, transferring ownership\nof the malloced array buffer to the store (own-put).\n\n@rst\nA key with the specified length is inserted into the store and associated with\nan array of the specified type and number of elements. The contents of the\nspecified key is copied, but the array buffer is taken directly and freed when\nthe store is closed. The array buffer must be a pointer returned by ``malloc``\nor ``calloc``. Ownership of the buffer is not taken unless the function returns\nsuccessfully.\n\nApart from taking ownership of the array buffer, the semantics of this\nfunction are identical to :c:func:`kastore_put`.\n@endrst\n\n@param self A pointer to a kastore object.\n@param key The key.\n@param key_len The length of the key.\n@param array The array. Must be a pointer returned by malloc/calloc.\n@param array_len The number of elements in the array.\n@param type The type of the array.\n@param flags The insertion flags. Currently unused.\n@return Return 0 on success or a negative value on failure.\n*/\nint kastore_oput(kastore_t *self, const char *key, size_t key_len, void *array,\n size_t array_len, int type, int flags);\n/**\n@brief Insert the specified NULL terminated key and array pair into the store,\ntransferring ownership of the malloced array buffer to the store (own-put).\n\n@rst\nAs for :c:func:`kastore_oput` except the key must be NULL-terminated C string.\n@endrst\n\n@param self A pointer to a kastore object.\n@param key The key.\n@param array The array. Must be a pointer returned by malloc/calloc.\n@param array_len The number of elements in the array.\n@param type The type of the array.\n@param flags The insertion flags. Currently unused.\n@return Return 0 on success or a negative value on failure.\n*/\nint kastore_oputs(kastore_t *self, const char *key, void *array, size_t array_len,\n int type, int flags);\n\n/**\n @defgroup TYPED_OPUTS_GROUP Typed own-and-put functions.\n @{\n */\n\nint kastore_oputs_int8(\n kastore_t *self, const char *key, int8_t *array, size_t array_len, int flags);\nint kastore_oputs_uint8(\n kastore_t *self, const char *key, uint8_t *array, size_t array_len, int flags);\nint kastore_oputs_int16(\n kastore_t *self, const char *key, int16_t *array, size_t array_len, int flags);\nint kastore_oputs_uint16(\n kastore_t *self, const char *key, uint16_t *array, size_t array_len, int flags);\nint kastore_oputs_int32(\n kastore_t *self, const char *key, int32_t *array, size_t array_len, int flags);\nint kastore_oputs_uint32(\n kastore_t *self, const char *key, uint32_t *array, size_t array_len, int flags);\nint kastore_oputs_int64(\n kastore_t *self, const char *key, int64_t *array, size_t array_len, int flags);\nint kastore_oputs_uint64(\n kastore_t *self, const char *key, uint64_t *array, size_t array_len, int flags);\nint kastore_oputs_float32(\n kastore_t *self, const char *key, float *array, size_t array_len, int flags);\nint kastore_oputs_float64(\n kastore_t *self, const char *key, double *array, size_t array_len, int flags);\n\n/** @} */\n\nvoid kastore_print_state(kastore_t *self, FILE *out);\n\n/**\n@brief Returns a description of the specified error code.\n\n@param err The error code.\n@return String describing the error code.\n*/\nconst char *kas_strerror(int err);\n\n/**\n@brief Returns the API version.\n\n@rst\nThe API follows the `semver convention `_, where the\nmajor, minor and patch numbers have specific meanings. The versioning\nscheme here also takes into account ABI compatability.\n@endrst\n*/\nkas_version_t kas_version(void);\n\n#define kas_safe_free(pointer) \\\n do { \\\n if (pointer != NULL) { \\\n free(pointer); \\\n pointer = NULL; \\\n } \\\n } while (0)\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif\n"
},
{
"path": "c/subprojects/kastore/meson.build",
"content": "project('kastore', ['c', 'cpp'],\n version: files('VERSION.txt'),\n default_options: [\n 'c_std=c99', \n 'cpp_std=c++11', \n 'warning_level=3', \n 'werror=true'])\n\nif not meson.is_subproject()\n add_global_arguments([\n '-W', '-Wmissing-prototypes', '-Wstrict-prototypes',\n '-Wconversion', '-Wshadow', '-Wpointer-arith', '-Wcast-align',\n '-Wcast-qual', '-Wwrite-strings', '-Wnested-externs',\n '-fshort-enums', '-fno-common'], language : 'c')\nendif\n\n# Subprojects should compile in the static library for simplicity.\nkastore_inc = include_directories('.')\nkastore = static_library('kastore', 'kastore.c')\nkastore_dep = declare_dependency(link_with : kastore, include_directories: kastore_inc)\n\nif not meson.is_subproject()\n\n # The shared library can be installed into the system.\n install_headers('kastore.h')\n shared_library('kastore', 'kastore.c', install: true)\n executable('example', ['example.c'], link_with: kastore)\n\n cunit_dep = dependency('cunit')\n src_root = meson.project_source_root()\n\n tests_exe = executable('tests', ['tests.c', 'kastore.c'], dependencies: cunit_dep,\n c_args: ['-DMESON_VERSION=\"@0@\"'.format(meson.project_version())])\n test('tests', tests_exe,\n env: ['KAS_TEST_DATA_PREFIX=' + src_root + '/test-data/'])\n\n cpp_tests_exe = executable('cpp_tests', ['cpp_tests.cpp'], link_with: kastore)\n test('cpp_tests', cpp_tests_exe)\n\n malloc_tests_exe = executable('malloc_tests', ['malloc_tests.c', 'kastore.c'],\n dependencies: cunit_dep,\n link_args:['-Wl,--wrap=malloc', '-Wl,--wrap=realloc', '-Wl,--wrap=calloc'])\n test('malloc_tests', malloc_tests_exe, workdir: src_root)\n\n io_tests_exe = executable('io_tests', ['io_tests.c', 'kastore.c'],\n dependencies: cunit_dep,\n link_args:[\n '-Wl,--wrap=fwrite',\n '-Wl,--wrap=fread',\n '-Wl,--wrap=fclose',\n '-Wl,--wrap=ftell',\n '-Wl,--wrap=fseek'])\n test('io_tests', io_tests_exe, workdir: src_root)\nendif\n"
},
{
"path": "c/tests/meson-subproject/example.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2022 Tskit Developers\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n/* Simple example testing that we compile and link in tskit and kastore\n * when we use meson submodules.\n */\n#include \n#include \n#include \n#include \n\nvoid\ntest_kas_strerror()\n{\n printf(\"test_kas_strerror\\n\");\n const char *str = kas_strerror(KAS_ERR_NO_MEMORY);\n assert(strcmp(str, \"Out of memory\") == 0);\n}\n\nvoid\ntest_strerror()\n{\n printf(\"test_strerror\\n\");\n const char *str = tsk_strerror(TSK_ERR_NO_MEMORY);\n assert(strcmp(str, \"Out of memory. (TSK_ERR_NO_MEMORY)\") == 0);\n}\n\nvoid\ntest_load_error()\n{\n printf(\"test_open_error\\n\");\n tsk_treeseq_t ts;\n int ret = tsk_treeseq_load(&ts, \"no such file\", 0);\n assert(ret == TSK_ERR_IO);\n tsk_treeseq_free(&ts);\n}\n\nvoid\ntest_table_basics()\n{\n printf(\"test_table_basics\\n\");\n tsk_table_collection_t tables;\n int ret = tsk_table_collection_init(&tables, 0);\n assert(ret == 0);\n\n ret = tsk_node_table_add_row(&tables.nodes, 0, 1.0, TSK_NULL, TSK_NULL, NULL, 0);\n assert(ret == 0);\n ret = tsk_node_table_add_row(&tables.nodes, 0, 2.0, TSK_NULL, TSK_NULL, NULL, 0);\n assert(ret == 1);\n assert(tables.nodes.num_rows == 2);\n\n tsk_table_collection_free(&tables);\n}\n\nint\nmain()\n{\n test_kas_strerror();\n test_strerror();\n test_load_error();\n test_table_basics();\n return 0;\n}\n"
},
{
"path": "c/tests/meson-subproject/meson.build",
"content": "project('example', 'c')\n\ntskit_proj = subproject('tskit')\ntskit_dep = tskit_proj.get_variable('tskit_dep')\n\nexecutable('example',\n 'example.c',\n dependencies : [tskit_dep],\n install : true)\n\n"
},
{
"path": "c/tests/test_convert.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2022 Tskit Developers\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \"testlib.h\"\n#include \n\n#include \n#include \n\nstatic void\ntest_single_tree_newick(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t t;\n size_t buffer_size = 1024;\n char newick[buffer_size];\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0)\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK)\n\n ret = tsk_convert_newick(&t, 0, 0, TSK_NEWICK_LEGACY_MS_LABELS, buffer_size, newick);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Seems odd, but this is what a single node newick tree looks like.\n * Newick parsers seems to accept it in any case */\n CU_ASSERT_STRING_EQUAL(newick, \"1;\");\n\n ret = tsk_convert_newick(&t, 0, 0, 0, buffer_size, newick);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_STRING_EQUAL(newick, \"n0;\");\n\n ret = tsk_convert_newick(&t, 4, 0, TSK_NEWICK_LEGACY_MS_LABELS, buffer_size, newick);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_STRING_EQUAL(newick, \"(1:1,2:1);\");\n ret = tsk_convert_newick(&t, 4, 0, 0, buffer_size, newick);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_STRING_EQUAL(newick, \"(n0:1,n1:1);\");\n\n ret = tsk_convert_newick(&t, 6, 0, TSK_NEWICK_LEGACY_MS_LABELS, buffer_size, newick);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_STRING_EQUAL(newick, \"((1:1,2:1):2,(3:2,4:2):1);\");\n\n ret = tsk_convert_newick(&t, 6, 0, 0, buffer_size, newick);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_STRING_EQUAL(newick, \"((n0:1,n1:1):2,(n2:2,n3:2):1);\");\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_newick_errors(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t t;\n size_t j, len;\n size_t buffer_size = 1024;\n char newick[buffer_size];\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0)\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK)\n\n ret = tsk_convert_newick(&t, -1, 1, 0, buffer_size, newick);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_convert_newick(&t, 7, 1, 0, buffer_size, newick);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n ret = tsk_convert_newick(&t, 6, 0, 0, buffer_size, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_convert_newick(&t, 6, 0, 0, buffer_size, newick);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n len = 1 + strlen(newick);\n for (j = 0; j < len; j++) {\n ret = tsk_convert_newick(&t, 6, 0, 0, j, newick);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BUFFER_OVERFLOW);\n }\n ret = tsk_convert_newick(&t, 6, 0, TSK_NEWICK_LEGACY_MS_LABELS, len, newick);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_STRING_EQUAL(newick, \"((1:1,2:1):2,(3:2,4:2):1);\");\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nint\nmain(int argc, char **argv)\n{\n CU_TestInfo tests[] = {\n { \"test_single_tree_newick\", test_single_tree_newick },\n { \"test_single_tree_newick_errors\", test_single_tree_newick_errors },\n { NULL, NULL },\n };\n return test_main(tests, argc, argv);\n}\n"
},
{
"path": "c/tests/test_core.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2024 Tskit Developers\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \"testlib.h\"\n#include \n#include \n#include \n\n#include \n\nstatic void\ntest_strerror(void)\n{\n int j;\n const char *msg;\n int max_error_code = 8192; /* totally arbitrary */\n\n for (j = 0; j < max_error_code; j++) {\n msg = tsk_strerror(-j);\n CU_ASSERT_FATAL(msg != NULL);\n CU_ASSERT(strlen(msg) > 0);\n }\n CU_ASSERT_STRING_EQUAL(\n tsk_strerror(0), \"Normal exit condition. This is not an error!\");\n}\n\nstatic void\ntest_strerror_kastore(void)\n{\n int kastore_errors[]\n = { KAS_ERR_NO_MEMORY, KAS_ERR_KEY_NOT_FOUND, KAS_ERR_BAD_FILE_FORMAT };\n size_t j;\n int err;\n\n for (j = 0; j < sizeof(kastore_errors) / sizeof(*kastore_errors); j++) {\n err = tsk_set_kas_error(kastore_errors[j]);\n CU_ASSERT_TRUE(tsk_is_kas_error(err));\n CU_ASSERT_EQUAL_FATAL(tsk_get_kas_error(err), kastore_errors[j]);\n CU_ASSERT_STRING_EQUAL(tsk_strerror(err), kas_strerror(kastore_errors[j]));\n }\n}\n\nstatic void\ntest_generate_uuid(void)\n{\n size_t uuid_size = 36;\n char uuid[uuid_size + 1];\n char other_uuid[uuid_size + 1];\n int ret;\n\n ret = tsk_generate_uuid(uuid, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(strlen(uuid), uuid_size);\n CU_ASSERT_EQUAL(uuid[8], '-');\n CU_ASSERT_EQUAL(uuid[13], '-');\n CU_ASSERT_EQUAL(uuid[18], '-');\n CU_ASSERT_EQUAL(uuid[23], '-');\n\n ret = tsk_generate_uuid(other_uuid, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(strlen(other_uuid), uuid_size);\n CU_ASSERT_STRING_NOT_EQUAL(uuid, other_uuid);\n}\n\nstatic void\ntest_double_round(void)\n{\n struct test_case {\n double source;\n unsigned int num_digits;\n double result;\n };\n struct test_case test_cases[] = {\n { 1.555, 3, 1.555 },\n { 1.5555, 2, 1.56 },\n /* catch the halfway between integers case */\n { 1.5555, 3, 1.556 },\n\n { 1.5111, 3, 1.511 },\n { 1.5112, 3, 1.511 },\n { 3.141592653589793, 0, 3.0 },\n { 3.141592653589793, 1, 3.1 },\n { 3.141592653589793, 2, 3.14 },\n { 3.141592653589793, 3, 3.142 },\n { 3.141592653589793, 4, 3.1416 },\n { 3.141592653589793, 5, 3.14159 },\n { 3.141592653589793, 6, 3.141593 },\n { 3.141592653589793, 7, 3.1415927 },\n { 3.141592653589793, 8, 3.14159265 },\n { 3.141592653589793, 9, 3.141592654 },\n { 3.141592653589793, 10, 3.1415926536 },\n { 3.141592653589793, 11, 3.14159265359 },\n { 3.141592653589793, 12, 3.14159265359 },\n { 3.141592653589793, 13, 3.1415926535898 },\n { 3.141592653589793, 14, 3.14159265358979 },\n { 3.141592653589793, 15, 3.141592653589793 },\n { 3.141592653589793, 16, 3.141592653589793 },\n { 3.141592653589793, 17, 3.141592653589793 },\n { 3.141592653589793, 18, 3.141592653589793 },\n { 3.141592653589793, 19, 3.141592653589793 },\n /* We have tiny differences in precision at k=20; not worth worrying about. */\n { 3.141592653589793, 21, 3.141592653589793 },\n { 3.141592653589793, 22, 3.141592653589793 },\n { 3.141592653589793, 23, 3.141592653589793 },\n\n { 0.3333333333333333, 0, 0.0 },\n { 0.3333333333333333, 1, 0.3 },\n { 0.3333333333333333, 2, 0.33 },\n { 0.3333333333333333, 3, 0.333 },\n { 0.3333333333333333, 4, 0.3333 },\n { 0.3333333333333333, 5, 0.33333 },\n { 0.3333333333333333, 6, 0.333333 },\n { 0.3333333333333333, 7, 0.3333333 },\n { 0.3333333333333333, 8, 0.33333333 },\n { 0.3333333333333333, 9, 0.333333333 },\n { 0.3333333333333333, 10, 0.3333333333 },\n { 0.3333333333333333, 11, 0.33333333333 },\n { 0.3333333333333333, 12, 0.333333333333 },\n { 0.3333333333333333, 13, 0.3333333333333 },\n { 0.3333333333333333, 14, 0.33333333333333 },\n { 0.3333333333333333, 15, 0.333333333333333 },\n { 0.3333333333333333, 16, 0.3333333333333333 },\n { 0.3333333333333333, 17, 0.3333333333333333 },\n { 0.3333333333333333, 18, 0.3333333333333333 },\n { 0.3333333333333333, 19, 0.3333333333333333 },\n { 0.3333333333333333, 20, 0.3333333333333333 },\n { 0.3333333333333333, 21, 0.3333333333333333 },\n { 0.3333333333333333, 22, 0.3333333333333333 },\n { 0.3333333333333333, 23, 0.3333333333333333 },\n\n { 0.6666666666666666, 0, 1.0 },\n { 0.6666666666666666, 1, 0.7 },\n { 0.6666666666666666, 2, 0.67 },\n { 0.6666666666666666, 3, 0.667 },\n { 0.6666666666666666, 4, 0.6667 },\n { 0.6666666666666666, 5, 0.66667 },\n { 0.6666666666666666, 6, 0.666667 },\n { 0.6666666666666666, 7, 0.6666667 },\n { 0.6666666666666666, 8, 0.66666667 },\n { 0.6666666666666666, 9, 0.666666667 },\n { 0.6666666666666666, 10, 0.6666666667 },\n { 0.6666666666666666, 11, 0.66666666667 },\n { 0.6666666666666666, 12, 0.666666666667 },\n { 0.6666666666666666, 13, 0.6666666666667 },\n { 0.6666666666666666, 14, 0.66666666666667 },\n { 0.6666666666666666, 15, 0.666666666666667 },\n { 0.6666666666666666, 16, 0.6666666666666666 },\n { 0.6666666666666666, 17, 0.6666666666666666 },\n { 0.6666666666666666, 18, 0.6666666666666666 },\n { 0.6666666666666666, 19, 0.6666666666666666 },\n { 0.6666666666666666, 20, 0.6666666666666666 },\n { 0.6666666666666666, 21, 0.6666666666666666 },\n { 0.6666666666666666, 22, 0.6666666666666666 },\n { 0.6666666666666666, 23, 0.6666666666666666 },\n\n { 0.07692307692307693, 0, 0.0 },\n { 0.07692307692307693, 1, 0.1 },\n { 0.07692307692307693, 2, 0.08 },\n { 0.07692307692307693, 3, 0.077 },\n { 0.07692307692307693, 4, 0.0769 },\n { 0.07692307692307693, 5, 0.07692 },\n { 0.07692307692307693, 6, 0.076923 },\n { 0.07692307692307693, 7, 0.0769231 },\n { 0.07692307692307693, 8, 0.07692308 },\n { 0.07692307692307693, 9, 0.076923077 },\n { 0.07692307692307693, 10, 0.0769230769 },\n { 0.07692307692307693, 11, 0.07692307692 },\n { 0.07692307692307693, 12, 0.076923076923 },\n { 0.07692307692307693, 13, 0.0769230769231 },\n { 0.07692307692307693, 14, 0.07692307692308 },\n { 0.07692307692307693, 15, 0.076923076923077 },\n { 0.07692307692307693, 16, 0.0769230769230769 },\n { 0.07692307692307693, 17, 0.07692307692307693 },\n { 0.07692307692307693, 18, 0.07692307692307693 },\n { 0.07692307692307693, 19, 0.07692307692307693 },\n { 0.07692307692307693, 20, 0.07692307692307693 },\n /* Tiny difference in precision at k=21 */\n { 0.07692307692307693, 22, 0.07692307692307693 },\n { 0.07692307692307693, 23, 0.07692307692307693 },\n\n { 1e-21, 0, 0.0 },\n { 1e-21, 1, 0.0 },\n { 1e-21, 2, 0.0 },\n { 1e-21, 3, 0.0 },\n { 1e-21, 4, 0.0 },\n { 1e-21, 5, 0.0 },\n { 1e-21, 6, 0.0 },\n { 1e-21, 7, 0.0 },\n { 1e-21, 8, 0.0 },\n { 1e-21, 9, 0.0 },\n { 1e-21, 10, 0.0 },\n { 1e-21, 11, 0.0 },\n { 1e-21, 12, 0.0 },\n { 1e-21, 13, 0.0 },\n { 1e-21, 14, 0.0 },\n { 1e-21, 15, 0.0 },\n { 1e-21, 16, 0.0 },\n { 1e-21, 17, 0.0 },\n { 1e-21, 18, 0.0 },\n { 1e-21, 19, 0.0 },\n { 1e-21, 20, 0.0 },\n { 1e-21, 21, 1e-21 },\n { 1e-21, 22, 1e-21 },\n { 1e-21, 23, 1e-21 },\n\n { 1e-10, 0, 0.0 },\n { 1e-10, 1, 0.0 },\n { 1e-10, 2, 0.0 },\n { 1e-10, 3, 0.0 },\n { 1e-10, 4, 0.0 },\n { 1e-10, 5, 0.0 },\n { 1e-10, 6, 0.0 },\n { 1e-10, 7, 0.0 },\n { 1e-10, 8, 0.0 },\n { 1e-10, 9, 0.0 },\n { 1e-10, 10, 1e-10 },\n { 1e-10, 11, 1e-10 },\n { 1e-10, 12, 1e-10 },\n { 1e-10, 13, 1e-10 },\n { 1e-10, 14, 1e-10 },\n { 1e-10, 15, 1e-10 },\n { 1e-10, 16, 1e-10 },\n { 1e-10, 17, 1e-10 },\n { 1e-10, 18, 1e-10 },\n { 1e-10, 19, 1e-10 },\n { 1e-10, 20, 1e-10 },\n { 1e-10, 21, 1e-10 },\n { 1e-10, 22, 1e-10 },\n { 1e-10, 23, 1e-10 },\n\n { 3.141592653589793e-08, 0, 0.0 },\n { 3.141592653589793e-08, 1, 0.0 },\n { 3.141592653589793e-08, 2, 0.0 },\n { 3.141592653589793e-08, 3, 0.0 },\n { 3.141592653589793e-08, 4, 0.0 },\n { 3.141592653589793e-08, 5, 0.0 },\n { 3.141592653589793e-08, 6, 0.0 },\n { 3.141592653589793e-08, 7, 0.0 },\n { 3.141592653589793e-08, 8, 3e-08 },\n { 3.141592653589793e-08, 9, 3.1e-08 },\n { 3.141592653589793e-08, 10, 3.14e-08 },\n { 3.141592653589793e-08, 11, 3.142e-08 },\n { 3.141592653589793e-08, 12, 3.1416e-08 },\n { 3.141592653589793e-08, 13, 3.14159e-08 },\n { 3.141592653589793e-08, 14, 3.141593e-08 },\n { 3.141592653589793e-08, 15, 3.1415927e-08 },\n { 3.141592653589793e-08, 16, 3.14159265e-08 },\n { 3.141592653589793e-08, 17, 3.141592654e-08 },\n { 3.141592653589793e-08, 18, 3.1415926536e-08 },\n { 3.141592653589793e-08, 19, 3.14159265359e-08 },\n { 3.141592653589793e-08, 20, 3.14159265359e-08 },\n { 3.141592653589793e-08, 21, 3.1415926535898e-08 },\n /* Tiny precision mismatch at k=22 */\n { 3.141592653589793e-08, 23, 3.141592653589793e-08 },\n\n };\n size_t num_test_cases = sizeof(test_cases) / sizeof(*test_cases);\n size_t j;\n\n for (j = 0; j < num_test_cases; j++) {\n CU_ASSERT_EQUAL_FATAL(tsk_round(test_cases[j].source, test_cases[j].num_digits),\n test_cases[j].result);\n }\n}\n\nstatic void\ntest_blkalloc(void)\n{\n tsk_blkalloc_t alloc;\n int ret;\n size_t j, block_size;\n void *mem;\n\n ret = tsk_blkalloc_init(&alloc, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n tsk_blkalloc_free(&alloc);\n\n for (block_size = 1; block_size < 10; block_size++) {\n ret = tsk_blkalloc_init(&alloc, block_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < 10; j++) {\n mem = tsk_blkalloc_get(&alloc, block_size);\n CU_ASSERT_TRUE(mem != NULL);\n CU_ASSERT_EQUAL(alloc.num_chunks, j + 1);\n tsk_memset(mem, 0, block_size);\n }\n\n mem = tsk_blkalloc_get(&alloc, block_size + 1);\n CU_ASSERT_EQUAL(mem, NULL);\n mem = tsk_blkalloc_get(&alloc, block_size + 2);\n CU_ASSERT_EQUAL(mem, NULL);\n\n tsk_blkalloc_print_state(&alloc, _devnull);\n tsk_blkalloc_free(&alloc);\n }\n\n /* Allocate awkward sized chunk */\n ret = tsk_blkalloc_init(&alloc, 100);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n mem = tsk_blkalloc_get(&alloc, 90);\n CU_ASSERT_FATAL(mem != NULL);\n tsk_memset(mem, 0, 90);\n mem = tsk_blkalloc_get(&alloc, 10);\n CU_ASSERT_FATAL(mem != NULL);\n tsk_memset(mem, 0, 10);\n CU_ASSERT_EQUAL(alloc.num_chunks, 1);\n mem = tsk_blkalloc_get(&alloc, 90);\n CU_ASSERT_FATAL(mem != NULL);\n tsk_memset(mem, 0, 90);\n CU_ASSERT_EQUAL(alloc.num_chunks, 2);\n mem = tsk_blkalloc_get(&alloc, 11);\n CU_ASSERT_FATAL(mem != NULL);\n tsk_memset(mem, 0, 11);\n CU_ASSERT_EQUAL(alloc.num_chunks, 3);\n\n tsk_blkalloc_free(&alloc);\n}\n\nstatic void\ntest_unknown_time(void)\n{\n CU_ASSERT_TRUE(tsk_isnan(TSK_UNKNOWN_TIME));\n CU_ASSERT_TRUE(tsk_is_unknown_time(TSK_UNKNOWN_TIME));\n CU_ASSERT_FALSE(tsk_is_unknown_time(NAN));\n CU_ASSERT_FALSE(tsk_is_unknown_time(0));\n CU_ASSERT_FALSE(tsk_is_unknown_time(INFINITY));\n CU_ASSERT_FALSE(tsk_is_unknown_time(1));\n}\n\nstatic void\ntest_malloc_zero(void)\n{\n void *p = tsk_malloc(0);\n\n CU_ASSERT_FATAL(p != NULL);\n free(p);\n\n p = tsk_calloc(0, 1);\n CU_ASSERT_FATAL(p != NULL);\n free(p);\n}\n\nstatic void\ntest_malloc_overflow(void)\n{\n#if TSK_MAX_SIZE > SIZE_MAX\n tsk_size_t size_max = SIZE_MAX;\n void *p = tsk_malloc(size_max + 1);\n CU_ASSERT_FATAL(p == NULL);\n\n p = tsk_calloc(size_max + 1, 1);\n CU_ASSERT_FATAL(p == NULL);\n#endif\n}\n\nstatic void\ntest_debug_stream(void)\n{\n FILE *f = fopen(_tmp_file_name, \"w\");\n CU_ASSERT_FATAL(tsk_get_debug_stream() == stdout);\n CU_ASSERT_FATAL(tsk_get_debug_stream() == stdout);\n\n tsk_set_debug_stream(f);\n CU_ASSERT_FATAL(tsk_get_debug_stream() == f);\n tsk_set_debug_stream(stdout);\n CU_ASSERT_FATAL(tsk_get_debug_stream() == stdout);\n\n fclose(f);\n}\n\nstatic int\nvalidate_avl_node(tsk_avl_node_int_t *node)\n{\n int height, lheight, rheight;\n\n if (node == NULL) {\n return 0;\n }\n lheight = validate_avl_node(node->llink);\n rheight = validate_avl_node(node->rlink);\n height = 1 + TSK_MAX(lheight, rheight);\n\n if (lheight != 0 && rheight != 0) {\n CU_ASSERT_FATAL(node->balance == rheight - lheight);\n } else if (lheight == 0 && rheight == 0) {\n CU_ASSERT_FATAL(height == 1);\n CU_ASSERT_FATAL(node->balance == 0);\n } else {\n CU_ASSERT_FATAL(height == 2);\n if (lheight == 0) {\n CU_ASSERT_FATAL(node->balance == 1);\n } else {\n CU_ASSERT_FATAL(node->balance == -1);\n }\n }\n return height;\n}\n\nstatic void\ntest_avl_empty(void)\n{\n int height;\n tsk_avl_tree_int_t tree;\n\n tsk_avl_tree_int_init(&tree);\n\n height = validate_avl_node(tree.head.rlink);\n CU_ASSERT_EQUAL((tsk_size_t) height, tree.height);\n CU_ASSERT_EQUAL(0, tree.size);\n tsk_avl_tree_int_print_state(&tree, _devnull);\n\n CU_ASSERT_EQUAL(tsk_avl_tree_int_search(&tree, -1), NULL);\n CU_ASSERT_EQUAL(tsk_avl_tree_int_search(&tree, 0), NULL);\n CU_ASSERT_EQUAL(tsk_avl_tree_int_search(&tree, 1), NULL);\n\n tsk_avl_tree_int_free(&tree);\n}\n\nstatic void\nvalidate_avl(size_t num_keys, int64_t *keys)\n{\n size_t j, k;\n int ret, height;\n tsk_avl_tree_int_t tree;\n tsk_avl_node_int_t *nodes = malloc(num_keys * sizeof(*nodes));\n tsk_avl_node_int_t **ordered_nodes = malloc(num_keys * sizeof(*ordered_nodes));\n tsk_avl_node_int_t *node;\n tsk_avl_node_int_t tmp_node;\n\n CU_ASSERT_FATAL(nodes != NULL);\n CU_ASSERT_FATAL(ordered_nodes != NULL);\n tsk_avl_tree_int_init(&tree);\n\n /* Assumes the keys are unique */\n for (j = 0; j < num_keys; j++) {\n node = nodes + j;\n node->key = keys[j];\n CU_ASSERT_EQUAL(tsk_avl_tree_int_search(&tree, keys[j]), NULL);\n ret = tsk_avl_tree_int_insert(&tree, node);\n CU_ASSERT_FATAL(ret == 0);\n CU_ASSERT_EQUAL(tsk_avl_tree_int_search(&tree, keys[j]), node);\n tmp_node.key = keys[j];\n ret = tsk_avl_tree_int_insert(&tree, &tmp_node);\n CU_ASSERT_FATAL(ret == 1);\n\n height = validate_avl_node(tree.head.rlink);\n CU_ASSERT_EQUAL((tsk_size_t) height, tree.height);\n CU_ASSERT_EQUAL(j + 1, tree.size);\n tsk_avl_tree_int_print_state(&tree, _devnull);\n for (k = j + 1; k < num_keys; k++) {\n CU_ASSERT_EQUAL(tsk_avl_tree_int_search(&tree, keys[k]), NULL);\n }\n }\n\n tsk_avl_tree_int_ordered_nodes(&tree, ordered_nodes);\n for (j = 0; j < num_keys; j++) {\n if (j > 0) {\n CU_ASSERT_FATAL(ordered_nodes[j - 1]->key < ordered_nodes[j]->key);\n }\n }\n\n tsk_avl_tree_int_free(&tree);\n free(nodes);\n free(ordered_nodes);\n}\n\nstatic void\ntest_avl_sequential(void)\n{\n int64_t keys[] = { 0, 1, 2, 3, 4, 5, 6, 7 };\n int64_t reversed_keys[] = { 7, 6, 5, 4, 3, 2, 1, 0 };\n\n validate_avl(8, keys);\n validate_avl(8, reversed_keys);\n}\n\nstatic void\ntest_avl_interleaved(void)\n{\n size_t num_keys = 100;\n size_t j;\n int64_t *keys = malloc(num_keys * sizeof(*keys));\n\n CU_ASSERT_FATAL(keys != NULL);\n for (j = 0; j < num_keys; j++) {\n keys[j] = (int64_t) j;\n if (j % 2 == 0) {\n keys[j] *= -1;\n }\n }\n validate_avl(num_keys, keys);\n free(keys);\n}\n\nstatic void\ntest_avl_random(void)\n{\n /* This example goes through all the code paths in the AVL insert algorithm */\n int64_t keys[] = { 2, 79, -8, -86, 6, -29, 88, -80, 21, -26, -13, 16, -1, 3, 51, 30,\n 49, -48, -99, 57, -63, 29, 91, 87, 60, -43, -79, -12, -52, -42, 69, 89, 74, -50,\n 7, -46, -37, 34, -28, 66, -83, 31, -41, -87, -92, -11, -17, -9, 10, 98, 71, -93,\n -66, -20, 63, -51, 33, -47, 5, -97, 90, 45, -57, 61, -6, -53, 99, -61, -19, -77,\n 53, 23, -60, 56, -56, -36, -30, 28, 35, -38, 38, 62, -68, 22, -96, -73, -89,\n 50 };\n\n validate_avl(sizeof(keys) / sizeof(*keys), keys);\n}\n\nstatic void\ntest_bit_arrays(void)\n{\n // NB: This test is only valid for the 32 bit implementation of bit arrays. If we\n // were to change the chunk size of a bit array, we'd need to update these tests\n tsk_bitset_t arr;\n tsk_id_t items_truth[64] = { 0 }, items[64] = { 0 };\n tsk_size_t n_items = 0, n_items_truth = 0;\n\n // test item retrieval\n tsk_bitset_init(&arr, 90, 1);\n CU_ASSERT_EQUAL_FATAL(arr.len, 1);\n CU_ASSERT_EQUAL_FATAL(arr.row_len, 3);\n tsk_bitset_get_items(&arr, 0, items, &n_items);\n assert_arrays_equal(n_items_truth, items, items_truth);\n\n for (tsk_bitset_val_t i = 0; i < 20; i++) {\n tsk_bitset_set_bit(&arr, 0, i);\n items_truth[n_items_truth] = (tsk_id_t) i;\n n_items_truth++;\n }\n tsk_bitset_set_bit(&arr, 0, 63);\n tsk_bitset_set_bit(&arr, 0, 65);\n\n // these assertions are only valid for 32-bit values\n CU_ASSERT_EQUAL_FATAL(arr.data[0], 1048575);\n CU_ASSERT_EQUAL_FATAL(arr.data[1], 2147483648);\n CU_ASSERT_EQUAL_FATAL(arr.data[2], 2);\n\n // verify our assumptions about bit array counting\n CU_ASSERT_EQUAL_FATAL(tsk_bitset_count(&arr, 0), 22);\n\n tsk_bitset_get_items(&arr, 0, items, &n_items);\n assert_arrays_equal(n_items_truth, items, items_truth);\n\n tsk_memset(items, 0, 64);\n tsk_memset(items_truth, 0, 64);\n n_items = n_items_truth = 0;\n tsk_bitset_free(&arr);\n\n // create a length-2 array with 64 bit capacity (two chunks per row)\n tsk_bitset_init(&arr, 64, 2);\n CU_ASSERT_EQUAL_FATAL(arr.len, 2);\n CU_ASSERT_EQUAL_FATAL(arr.row_len, 2);\n\n // fill the first 50 bits of the first row\n for (tsk_bitset_val_t i = 0; i < 50; i++) {\n tsk_bitset_set_bit(&arr, 0, i);\n items_truth[n_items_truth] = (tsk_id_t) i;\n n_items_truth++;\n }\n\n tsk_bitset_get_items(&arr, 0, items, &n_items);\n assert_arrays_equal(n_items_truth, items, items_truth);\n\n tsk_memset(items, 0, 64);\n tsk_memset(items_truth, 0, 64);\n n_items = n_items_truth = 0;\n\n // fill bits 20-40 of the second row\n for (tsk_bitset_val_t i = 20; i < 40; i++) {\n tsk_bitset_set_bit(&arr, 1, i);\n items_truth[n_items_truth] = (tsk_id_t) i;\n n_items_truth++;\n }\n\n tsk_bitset_get_items(&arr, 1, items, &n_items);\n assert_arrays_equal(n_items_truth, items, items_truth);\n\n tsk_memset(items, 0, 64);\n tsk_memset(items_truth, 0, 64);\n n_items = n_items_truth = 0;\n\n // verify our assumptions about row selection\n CU_ASSERT_EQUAL_FATAL(arr.data[0], 4294967295); // row1 elem1\n CU_ASSERT_EQUAL_FATAL(arr.data[1], 262143); // row1 elem2\n CU_ASSERT_EQUAL_FATAL(arr.data[2], 4293918720); // row2 elem1\n CU_ASSERT_EQUAL_FATAL(arr.data[3], 255); // row2 elem2\n\n // subtract the second from the first row, store in first\n tsk_bitset_subtract(&arr, 0, &arr, 1);\n\n // verify our assumptions about subtraction\n CU_ASSERT_EQUAL_FATAL(arr.data[0], 1048575);\n CU_ASSERT_EQUAL_FATAL(arr.data[1], 261888);\n\n tsk_bitset_t int_result;\n tsk_bitset_init(&int_result, 64, 1);\n CU_ASSERT_EQUAL_FATAL(int_result.len, 1);\n CU_ASSERT_EQUAL_FATAL(int_result.row_len, 2);\n\n // their intersection should be zero\n tsk_bitset_intersect(&arr, 0, &arr, 1, &int_result);\n CU_ASSERT_EQUAL_FATAL(int_result.data[0], 0);\n CU_ASSERT_EQUAL_FATAL(int_result.data[1], 0);\n\n // now, add them back together, storing back in a\n tsk_bitset_union(&arr, 0, &arr, 1);\n\n // now, their intersection should be the subtracted chunk (20-40)\n tsk_bitset_intersect(&arr, 0, &arr, 1, &int_result);\n CU_ASSERT_EQUAL_FATAL(int_result.data[0], 4293918720);\n CU_ASSERT_EQUAL_FATAL(int_result.data[1], 255);\n\n tsk_bitset_free(&int_result);\n tsk_bitset_free(&arr);\n}\n\nstatic void\ntest_meson_version(void)\n{\n char version[100];\n\n sprintf(\n version, \"%d.%d.%d\", TSK_VERSION_MAJOR, TSK_VERSION_MINOR, TSK_VERSION_PATCH);\n /* the MESON_PROJECT_VERSION define is passed in by meson when compiling */\n CU_ASSERT_STRING_EQUAL(version, MESON_PROJECT_VERSION);\n}\n\nint\nmain(int argc, char **argv)\n{\n CU_TestInfo tests[] = {\n { \"test_strerror\", test_strerror },\n { \"test_strerror_kastore\", test_strerror_kastore },\n { \"test_generate_uuid\", test_generate_uuid },\n { \"test_double_round\", test_double_round },\n { \"test_blkalloc\", test_blkalloc },\n { \"test_unknown_time\", test_unknown_time },\n { \"test_malloc_zero\", test_malloc_zero },\n { \"test_malloc_overflow\", test_malloc_overflow },\n { \"test_debug_stream\", test_debug_stream },\n { \"test_avl_empty\", test_avl_empty },\n { \"test_avl_sequential\", test_avl_sequential },\n { \"test_avl_interleaved\", test_avl_interleaved },\n { \"test_avl_random\", test_avl_random },\n { \"test_bit_arrays\", test_bit_arrays },\n { \"test_meson_version\", test_meson_version },\n { NULL, NULL },\n };\n\n return test_main(tests, argc, argv);\n}\n"
},
{
"path": "c/tests/test_file_format.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2022 Tskit Developers\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, mergetest, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \"testlib.h\"\n#include \n\ntypedef struct {\n const char *name;\n void *array;\n tsk_size_t len;\n int type;\n} write_table_col_t;\n\nstatic void\nwrite_table_cols(kastore_t *store, write_table_col_t *write_cols, size_t num_cols)\n{\n size_t j;\n int ret;\n\n for (j = 0; j < num_cols; j++) {\n ret = kastore_puts(store, write_cols[j].name, write_cols[j].array,\n (size_t) write_cols[j].len, write_cols[j].type, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n }\n}\n\nstatic void\ncopy_store_drop_columns(\n tsk_treeseq_t *ts, size_t num_drop_cols, const char **drop_cols, const char *outfile)\n{\n int ret = 0;\n char tmpfile[] = \"/tmp/tsk_c_test_copy_XXXXXX\";\n int fd;\n kastore_t read_store, write_store;\n kaitem_t *item;\n size_t j, k;\n bool keep;\n\n fd = mkstemp(tmpfile);\n CU_ASSERT_FATAL(fd != -1);\n close(fd);\n\n ret = tsk_treeseq_dump(ts, tmpfile, 0);\n if (ret != 0) {\n unlink(tmpfile);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n }\n\n ret = kastore_open(&read_store, tmpfile, \"r\", KAS_READ_ALL);\n /* We can now unlink the file as either kastore has read it all, or failed */\n unlink(tmpfile);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = kastore_open(&write_store, outfile, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Note: this API is not a documented part of kastore, so may be subject to\n * change. */\n for (j = 0; j < read_store.num_items; j++) {\n item = &read_store.items[j];\n keep = true;\n for (k = 0; k < num_drop_cols; k++) {\n if (strlen(drop_cols[k]) == item->key_len\n && strncmp(drop_cols[k], item->key, item->key_len) == 0) {\n keep = false;\n break;\n }\n }\n if (keep) {\n ret = kastore_put(&write_store, item->key, item->key_len, item->array,\n item->array_len, item->type, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n }\n }\n kastore_close(&read_store);\n ret = kastore_close(&write_store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n}\n\nstatic void\ntest_format_data_load_errors(void)\n{\n size_t uuid_size = 36;\n char uuid[uuid_size];\n char format_name[TSK_FILE_FORMAT_NAME_LENGTH];\n double L[2];\n uint32_t version[2]\n = { TSK_FILE_FORMAT_VERSION_MAJOR, TSK_FILE_FORMAT_VERSION_MINOR };\n write_table_col_t write_cols[] = {\n { \"format/name\", (void *) format_name, sizeof(format_name), KAS_INT8 },\n { \"format/version\", (void *) version, 2, KAS_UINT32 },\n { \"sequence_length\", (void *) L, 1, KAS_FLOAT64 },\n { \"uuid\", (void *) uuid, (tsk_size_t) uuid_size, KAS_INT8 },\n };\n tsk_table_collection_t tables;\n kastore_t store;\n size_t j;\n int ret;\n\n L[0] = 1;\n L[1] = 0;\n tsk_memcpy(format_name, TSK_FILE_FORMAT_NAME, sizeof(format_name));\n /* Note: this will fail if we ever start parsing the form of the UUID */\n tsk_memset(uuid, 0, uuid_size);\n\n ret = kastore_open(&store, _tmp_file_name, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_table_cols(&store, write_cols, sizeof(write_cols) / sizeof(*write_cols));\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n /* We've only defined the format headers, so we should fail immediately\n * after with required columns not found */\n CU_ASSERT_FALSE(tsk_is_kas_error(ret));\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_REQUIRED_COL_NOT_FOUND);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Version too old */\n version[0] = TSK_FILE_FORMAT_VERSION_MAJOR - 1;\n ret = kastore_open(&store, _tmp_file_name, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_table_cols(&store, write_cols, sizeof(write_cols) / sizeof(*write_cols));\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_FILE_VERSION_TOO_OLD);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Version too new */\n version[0] = TSK_FILE_FORMAT_VERSION_MAJOR + 1;\n ret = kastore_open(&store, _tmp_file_name, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_table_cols(&store, write_cols, sizeof(write_cols) / sizeof(*write_cols));\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_FILE_VERSION_TOO_NEW);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n version[0] = TSK_FILE_FORMAT_VERSION_MAJOR;\n\n /* Bad version length */\n write_cols[1].len = 0;\n ret = kastore_open(&store, _tmp_file_name, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_table_cols(&store, write_cols, sizeof(write_cols) / sizeof(*write_cols));\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_FILE_FORMAT);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_cols[1].len = 2;\n\n /* Bad format name length */\n write_cols[0].len = 0;\n ret = kastore_open(&store, _tmp_file_name, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_table_cols(&store, write_cols, sizeof(write_cols) / sizeof(*write_cols));\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_FILE_FORMAT);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_cols[0].len = TSK_FILE_FORMAT_NAME_LENGTH;\n\n /* Bad format name */\n format_name[0] = 'X';\n ret = kastore_open(&store, _tmp_file_name, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_table_cols(&store, write_cols, sizeof(write_cols) / sizeof(*write_cols));\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_FILE_FORMAT);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n format_name[0] = 't';\n\n /* Bad type for sequence length. */\n write_cols[2].type = KAS_FLOAT32;\n ret = kastore_open(&store, _tmp_file_name, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_table_cols(&store, write_cols, sizeof(write_cols) / sizeof(*write_cols));\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_TRUE(tsk_is_kas_error(ret));\n CU_ASSERT_EQUAL_FATAL(ret ^ (1 << TSK_KAS_ERR_BIT), KAS_ERR_TYPE_MISMATCH);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_cols[2].type = KAS_FLOAT64;\n\n /* Bad length for sequence length. */\n write_cols[2].len = 2;\n ret = kastore_open(&store, _tmp_file_name, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_table_cols(&store, write_cols, sizeof(write_cols) / sizeof(*write_cols));\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_FILE_FORMAT);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_cols[2].len = 1;\n\n /* Bad value for sequence length. */\n L[0] = -1;\n ret = kastore_open(&store, _tmp_file_name, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_table_cols(&store, write_cols, sizeof(write_cols) / sizeof(*write_cols));\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SEQUENCE_LENGTH);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n L[0] = 1;\n\n /* Wrong length for uuid */\n write_cols[3].len = 1;\n ret = kastore_open(&store, _tmp_file_name, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_table_cols(&store, write_cols, sizeof(write_cols) / sizeof(*write_cols));\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_FILE_FORMAT);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_cols[3].len = (tsk_size_t) uuid_size;\n\n /* Missing keys */\n for (j = 0; j < sizeof(write_cols) / sizeof(*write_cols) - 1; j++) {\n ret = kastore_open(&store, _tmp_file_name, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_table_cols(&store, write_cols, j);\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_REQUIRED_COL_NOT_FOUND);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n }\n}\n\nstatic void\ntest_missing_optional_column_pairs(void)\n{\n int ret;\n size_t j;\n tsk_treeseq_t *ts = caterpillar_tree(5, 3, 3);\n tsk_table_collection_t t1, t2;\n const char *required_cols[][2] = { { \"edges/metadata\", \"edges/metadata_offset\" },\n { \"migrations/metadata\", \"migrations/metadata_offset\" },\n { \"individuals/parents\", \"individuals/parents_offset\" } };\n const char *drop_cols[2];\n\n ret = tsk_treeseq_copy_tables(ts, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < sizeof(required_cols) / sizeof(*required_cols); j++) {\n drop_cols[0] = required_cols[j][0];\n copy_store_drop_columns(ts, 1, drop_cols, _tmp_file_name);\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BOTH_COLUMNS_REQUIRED);\n tsk_table_collection_free(&t2);\n\n drop_cols[0] = required_cols[j][1];\n copy_store_drop_columns(ts, 1, drop_cols, _tmp_file_name);\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BOTH_COLUMNS_REQUIRED);\n tsk_table_collection_free(&t2);\n\n drop_cols[0] = required_cols[j][0];\n drop_cols[1] = required_cols[j][1];\n copy_store_drop_columns(ts, 2, drop_cols, _tmp_file_name);\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&t1, &t2, 0));\n tsk_table_collection_free(&t2);\n }\n\n tsk_table_collection_free(&t1);\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\ntest_missing_required_column_pairs(void)\n{\n int ret;\n size_t j;\n tsk_treeseq_t *ts = caterpillar_tree(5, 3, 3);\n tsk_table_collection_t t;\n const char *required_cols[][2] = {\n { \"individuals/location\", \"individuals/location_offset\" },\n { \"individuals/metadata\", \"individuals/metadata_offset\" },\n { \"mutations/derived_state\", \"mutations/derived_state_offset\" },\n { \"mutations/metadata\", \"mutations/metadata_offset\" },\n { \"nodes/metadata\", \"nodes/metadata_offset\" },\n { \"populations/metadata\", \"populations/metadata_offset\" },\n { \"provenances/record\", \"provenances/record_offset\" },\n { \"provenances/timestamp\", \"provenances/timestamp_offset\" },\n { \"sites/ancestral_state\", \"sites/ancestral_state_offset\" },\n { \"sites/metadata\", \"sites/metadata_offset\" },\n };\n const char *drop_cols[2];\n\n for (j = 0; j < sizeof(required_cols) / sizeof(*required_cols); j++) {\n drop_cols[0] = required_cols[j][0];\n copy_store_drop_columns(ts, 1, drop_cols, _tmp_file_name);\n ret = tsk_table_collection_load(&t, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_REQUIRED_COL_NOT_FOUND);\n tsk_table_collection_free(&t);\n\n drop_cols[0] = required_cols[j][1];\n copy_store_drop_columns(ts, 1, drop_cols, _tmp_file_name);\n ret = tsk_table_collection_load(&t, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BOTH_COLUMNS_REQUIRED);\n tsk_table_collection_free(&t);\n\n copy_store_drop_columns(ts, 2, required_cols[j], _tmp_file_name);\n ret = tsk_table_collection_load(&t, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_REQUIRED_COL_NOT_FOUND);\n tsk_table_collection_free(&t);\n }\n\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\nverify_bad_offset_columns(tsk_treeseq_t *ts, const char *offset_col)\n{\n int ret = 0;\n kastore_t store;\n tsk_table_collection_t tables;\n uint32_t *offset_array, *offset_copy;\n size_t offset_len;\n int type;\n uint32_t data_len;\n\n ret = tsk_treeseq_dump(ts, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_open(&store, _tmp_file_name, \"r\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = kastore_gets(&store, offset_col, (void **) &offset_array, &offset_len, &type);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(type, KAS_UINT32);\n offset_copy = malloc(offset_len * sizeof(*offset_array));\n CU_ASSERT_FATAL(offset_copy != NULL);\n tsk_memcpy(offset_copy, offset_array, offset_len * sizeof(*offset_array));\n data_len = offset_array[offset_len - 1];\n CU_ASSERT_TRUE(data_len > 0);\n kastore_close(&store);\n\n offset_copy[0] = UINT32_MAX;\n copy_store_drop_columns(ts, 1, &offset_col, _tmp_file_name);\n ret = kastore_open(&store, _tmp_file_name, \"a\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(&store, offset_col, offset_copy, offset_len, KAS_UINT32, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_OFFSET);\n tsk_table_collection_free(&tables);\n\n offset_copy[0] = 0;\n offset_copy[offset_len - 1] = 0;\n copy_store_drop_columns(ts, 1, &offset_col, _tmp_file_name);\n ret = kastore_open(&store, _tmp_file_name, \"a\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(&store, offset_col, offset_copy, offset_len, KAS_UINT32, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_OFFSET);\n tsk_table_collection_free(&tables);\n\n offset_copy[offset_len - 1] = data_len + 1;\n copy_store_drop_columns(ts, 1, &offset_col, _tmp_file_name);\n ret = kastore_open(&store, _tmp_file_name, \"a\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(&store, offset_col, offset_copy, offset_len, KAS_UINT32, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_OFFSET);\n tsk_table_collection_free(&tables);\n\n copy_store_drop_columns(ts, 1, &offset_col, _tmp_file_name);\n ret = kastore_open(&store, _tmp_file_name, \"a\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(&store, offset_col, NULL, 0, KAS_UINT32, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_FILE_FORMAT);\n tsk_table_collection_free(&tables);\n\n copy_store_drop_columns(ts, 1, &offset_col, _tmp_file_name);\n ret = kastore_open(&store, _tmp_file_name, \"a\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(&store, offset_col, offset_copy, offset_len, KAS_FLOAT32, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_COLUMN_TYPE);\n tsk_table_collection_free(&tables);\n\n free(offset_copy);\n}\n\nstatic void\ntest_bad_offset_columns(void)\n{\n size_t j;\n tsk_treeseq_t *ts = caterpillar_tree(5, 3, 3);\n /* We exclude \"provenances/timestamp_offset\" here because there are no\n * non-ragged columns in the provenances table, so this doesn't quite\n * fit into the same pattern as the other tables */\n const char *cols[] = {\n \"edges/metadata_offset\",\n \"migrations/metadata_offset\",\n \"individuals/location_offset\",\n \"individuals/parents_offset\",\n \"individuals/metadata_offset\",\n \"mutations/derived_state_offset\",\n \"mutations/metadata_offset\",\n \"nodes/metadata_offset\",\n \"populations/metadata_offset\",\n \"provenances/record_offset\",\n \"sites/ancestral_state_offset\",\n \"sites/metadata_offset\",\n };\n\n for (j = 0; j < sizeof(cols) / sizeof(*cols); j++) {\n verify_bad_offset_columns(ts, cols[j]);\n }\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\ntest_force_offset_64(void)\n{\n int ret;\n tsk_treeseq_t *ts = caterpillar_tree(5, 3, 3);\n tsk_table_collection_t t1;\n tsk_table_collection_t t2;\n kastore_t store;\n kaitem_t *item;\n const char *suffix;\n const char *offset_str = \"_offset\";\n int num_found = 0;\n size_t j;\n\n ret = tsk_treeseq_dump(ts, _tmp_file_name, TSK_DUMP_FORCE_OFFSET_64);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = kastore_open(&store, _tmp_file_name, \"r\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = 0; j < store.num_items; j++) {\n item = &store.items[j];\n /* Does the key end in \"_offset\"? */\n if (item->key_len > strlen(offset_str)) {\n suffix = item->key + (item->key_len - strlen(offset_str));\n if (strncmp(suffix, offset_str, strlen(offset_str)) == 0) {\n CU_ASSERT_EQUAL(item->type, KAS_UINT64);\n num_found++;\n }\n }\n }\n CU_ASSERT_TRUE(num_found > 0);\n kastore_close(&store);\n\n ret = tsk_table_collection_load(&t1, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_copy_tables(ts, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n\n tsk_table_collection_free(&t1);\n tsk_table_collection_free(&t2);\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\ntest_missing_indexes(void)\n{\n int ret;\n tsk_treeseq_t *ts = caterpillar_tree(5, 3, 3);\n tsk_table_collection_t t1, t2;\n const char *cols[]\n = { \"indexes/edge_insertion_order\", \"indexes/edge_removal_order\" };\n const char *drop_cols[2];\n\n ret = tsk_treeseq_copy_tables(ts, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n drop_cols[0] = cols[0];\n copy_store_drop_columns(ts, 1, drop_cols, _tmp_file_name);\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BOTH_COLUMNS_REQUIRED);\n tsk_table_collection_free(&t2);\n\n drop_cols[0] = cols[1];\n copy_store_drop_columns(ts, 1, drop_cols, _tmp_file_name);\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BOTH_COLUMNS_REQUIRED);\n tsk_table_collection_free(&t2);\n\n copy_store_drop_columns(ts, 2, cols, _tmp_file_name);\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n CU_ASSERT_FALSE(tsk_table_collection_has_index(&t2, 0));\n tsk_table_collection_free(&t2);\n\n tsk_table_collection_free(&t1);\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\ntest_malformed_indexes(void)\n{\n int ret;\n tsk_treeseq_t *ts = caterpillar_tree(5, 3, 3);\n tsk_table_collection_t tables;\n tsk_treeseq_t ts2;\n tsk_size_t num_edges = tsk_treeseq_get_num_edges(ts);\n tsk_id_t *bad_index = tsk_calloc(num_edges, sizeof(tsk_id_t));\n tsk_id_t *good_index = tsk_calloc(num_edges, sizeof(tsk_id_t));\n kastore_t store;\n const char *cols[]\n = { \"indexes/edge_insertion_order\", \"indexes/edge_removal_order\" };\n\n CU_ASSERT_FATAL(bad_index != NULL);\n CU_ASSERT_FATAL(good_index != NULL);\n\n /* If both columns are not the same length as the number of edges we\n * should raise an error */\n copy_store_drop_columns(ts, 2, cols, _tmp_file_name);\n ret = kastore_open(&store, _tmp_file_name, \"a\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(&store, cols[0], NULL, 0, TSK_ID_STORAGE_TYPE, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(&store, cols[1], NULL, 0, TSK_ID_STORAGE_TYPE, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_FILE_FORMAT);\n tsk_table_collection_free(&tables);\n\n bad_index[0] = -1;\n\n copy_store_drop_columns(ts, 2, cols, _tmp_file_name);\n ret = kastore_open(&store, _tmp_file_name, \"a\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(\n &store, cols[0], good_index, (size_t) num_edges, TSK_ID_STORAGE_TYPE, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(\n &store, cols[1], bad_index, (size_t) num_edges, TSK_ID_STORAGE_TYPE, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_load(&ts2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts2);\n\n copy_store_drop_columns(ts, 2, cols, _tmp_file_name);\n ret = kastore_open(&store, _tmp_file_name, \"a\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(\n &store, cols[0], bad_index, (size_t) num_edges, TSK_ID_STORAGE_TYPE, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(\n &store, cols[1], good_index, (size_t) num_edges, TSK_ID_STORAGE_TYPE, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_load(&ts2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts2);\n\n copy_store_drop_columns(ts, 1, cols, _tmp_file_name);\n ret = kastore_open(&store, _tmp_file_name, \"a\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(&store, cols[0], bad_index, (size_t) num_edges, KAS_FLOAT32, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_load(&ts2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_COLUMN_TYPE);\n tsk_treeseq_free(&ts2);\n\n free(good_index);\n free(bad_index);\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\ntest_missing_reference_sequence(void)\n{\n int ret;\n tsk_treeseq_t *ts = caterpillar_tree(5, 3, 3);\n tsk_table_collection_t t1, t2;\n const char *cols[] = { \"reference_sequence/data\", \"reference_sequence/url\",\n \"reference_sequence/metadata_schema\", \"reference_sequence/metadata\" };\n\n CU_ASSERT_TRUE(tsk_treeseq_has_reference_sequence(ts));\n\n ret = tsk_treeseq_copy_tables(ts, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n copy_store_drop_columns(ts, 1, cols, _tmp_file_name);\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_TRUE(tsk_table_collection_has_reference_sequence(&t2));\n tsk_table_collection_free(&t2);\n\n copy_store_drop_columns(ts, 2, cols, _tmp_file_name);\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_TRUE(tsk_table_collection_has_reference_sequence(&t2));\n tsk_table_collection_free(&t2);\n\n copy_store_drop_columns(ts, 3, cols, _tmp_file_name);\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_TRUE(tsk_table_collection_has_reference_sequence(&t2));\n tsk_table_collection_free(&t2);\n\n /* Dropping all the columns gives us a NULL reference_sequence, though */\n copy_store_drop_columns(ts, 4, cols, _tmp_file_name);\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_has_reference_sequence(&t2));\n tsk_table_collection_free(&t2);\n\n tsk_table_collection_free(&t1);\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\ntest_bad_column_types(void)\n{\n int ret;\n tsk_treeseq_t *ts = caterpillar_tree(5, 3, 3);\n tsk_table_collection_t tables;\n tsk_size_t num_edges = tsk_treeseq_get_num_edges(ts);\n /* make sure we have enough memory in all cases */\n tsk_id_t *col_memory = tsk_calloc(num_edges + 1, sizeof(double));\n kastore_t store;\n const char *cols[1];\n\n CU_ASSERT_FATAL(col_memory != NULL);\n\n cols[0] = \"edges/left\";\n copy_store_drop_columns(ts, 1, cols, _tmp_file_name);\n ret = kastore_open(&store, _tmp_file_name, \"a\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(&store, cols[0], col_memory, (size_t) num_edges, KAS_FLOAT32, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_COLUMN_TYPE);\n tsk_table_collection_free(&tables);\n\n cols[0] = \"edges/metadata_offset\";\n copy_store_drop_columns(ts, 1, cols, _tmp_file_name);\n ret = kastore_open(&store, _tmp_file_name, \"a\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(\n &store, cols[0], col_memory, (size_t) num_edges + 1, KAS_FLOAT32, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_COLUMN_TYPE);\n tsk_table_collection_free(&tables);\n\n cols[0] = \"edges/metadata\";\n copy_store_drop_columns(ts, 1, cols, _tmp_file_name);\n ret = kastore_open(&store, _tmp_file_name, \"a\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(&store, cols[0], NULL, 0, KAS_FLOAT32, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_COLUMN_TYPE);\n tsk_table_collection_free(&tables);\n\n cols[0] = \"edges/metadata_schema\";\n copy_store_drop_columns(ts, 1, cols, _tmp_file_name);\n ret = kastore_open(&store, _tmp_file_name, \"a\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(&store, cols[0], NULL, 0, KAS_FLOAT32, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_COLUMN_TYPE);\n tsk_table_collection_free(&tables);\n\n cols[0] = \"reference_sequence/metadata\";\n copy_store_drop_columns(ts, 1, cols, _tmp_file_name);\n ret = kastore_open(&store, _tmp_file_name, \"a\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_puts(&store, cols[0], NULL, 0, KAS_FLOAT32, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_COLUMN_TYPE);\n tsk_table_collection_free(&tables);\n\n free(col_memory);\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\ntest_missing_required_columns(void)\n{\n int ret;\n size_t j;\n tsk_treeseq_t *ts = caterpillar_tree(5, 3, 3);\n tsk_table_collection_t t;\n const char *required_cols[] = {\n \"edges/child\",\n \"edges/left\",\n \"edges/parent\",\n \"edges/right\",\n \"format/name\",\n \"format/version\",\n \"individuals/flags\",\n \"migrations/dest\",\n \"migrations/left\",\n \"migrations/node\",\n \"migrations/right\",\n \"migrations/source\",\n \"migrations/time\",\n \"mutations/node\",\n \"mutations/parent\",\n \"mutations/site\",\n \"nodes/flags\",\n \"nodes/individual\",\n \"nodes/population\",\n \"nodes/time\",\n \"sequence_length\",\n \"sites/position\",\n \"uuid\",\n };\n const char *drop_cols[1];\n\n for (j = 0; j < sizeof(required_cols) / sizeof(*required_cols); j++) {\n drop_cols[0] = required_cols[j];\n copy_store_drop_columns(ts, 1, drop_cols, _tmp_file_name);\n ret = tsk_table_collection_load(&t, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_REQUIRED_COL_NOT_FOUND);\n tsk_table_collection_free(&t);\n }\n\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\ntest_metadata_schemas_optional(void)\n{\n int ret;\n size_t j;\n tsk_treeseq_t *ts = caterpillar_tree(5, 3, 3);\n tsk_table_collection_t t1, t2;\n const char *cols[] = {\n \"metadata\",\n \"metadata_schema\",\n \"reference_sequence/metadata\",\n \"reference_sequence/metadata_schema\",\n \"individuals/metadata_schema\",\n \"populations/metadata_schema\",\n \"nodes/metadata_schema\",\n \"edges/metadata_schema\",\n \"sites/metadata_schema\",\n \"mutations/metadata_schema\",\n \"migrations/metadata_schema\",\n };\n const char *drop_cols[1];\n\n ret = tsk_treeseq_copy_tables(ts, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < sizeof(cols) / sizeof(*cols); j++) {\n drop_cols[0] = cols[j];\n copy_store_drop_columns(ts, 1, drop_cols, _tmp_file_name);\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* metadata schemas are included in data comparisons */\n CU_ASSERT_FALSE(tsk_table_collection_equals(&t1, &t2, 0));\n tsk_table_collection_free(&t2);\n }\n\n tsk_table_collection_free(&t1);\n tsk_treeseq_free(ts);\n free(ts);\n}\n\n/* This test is problematic on windows because of the different off_t\n * types. Doesn't seem worth the trouble of getting it working.\n */\nstatic void\ntest_load_bad_file_formats(void)\n{\n#if !defined(_WIN32)\n tsk_table_collection_t tables;\n tsk_treeseq_t ts;\n int ret, ret2;\n off_t offset;\n FILE *f;\n\n /* A zero byte file is TSK_ERR_EOF */\n f = fopen(_tmp_file_name, \"w+\");\n ret = tsk_table_collection_loadf(&tables, f, 0);\n ret2 = tsk_treeseq_loadf(&ts, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, ret2);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EOF);\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n fclose(f);\n\n for (offset = 1; offset < 100; offset++) {\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1.0;\n ret = tsk_table_collection_dump(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret2 = truncate(_tmp_file_name, offset);\n CU_ASSERT_EQUAL_FATAL(ret2, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret ^ (1 << TSK_KAS_ERR_BIT), KAS_ERR_BAD_FILE_FORMAT);\n tsk_table_collection_free(&tables);\n }\n#endif\n}\n\nstatic void\ntest_load_errors(void)\n{\n tsk_table_collection_t tables;\n tsk_treeseq_t ts;\n int ret, ret2;\n const char *str;\n FILE *f;\n\n ret = tsk_table_collection_load(&tables, \"/\", 0);\n ret2 = tsk_treeseq_load(&ts, \"/\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, ret2);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_IO);\n str = tsk_strerror(ret);\n CU_ASSERT_TRUE(strlen(str) > 0);\n CU_ASSERT_STRING_EQUAL(str, strerror(EISDIR));\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n\n ret = tsk_table_collection_load(&tables, \"/bin/theres_no_way_this_file_exists\", 0);\n ret2 = tsk_treeseq_load(&ts, \"/bin/theres_no_way_this_file_exists\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, ret2);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_IO);\n str = tsk_strerror(ret);\n CU_ASSERT_TRUE(strlen(str) > 0);\n CU_ASSERT_STRING_EQUAL(str, strerror(ENOENT));\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n\n ret = tsk_table_collection_load(&tables, \"/bin/sh\", 0);\n ret2 = tsk_treeseq_load(&ts, \"/bin/sh\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, ret2);\n CU_ASSERT_TRUE(tsk_is_kas_error(ret));\n CU_ASSERT_EQUAL_FATAL(ret ^ (1 << TSK_KAS_ERR_BIT), KAS_ERR_BAD_FILE_FORMAT);\n str = tsk_strerror(ret);\n CU_ASSERT_TRUE(strlen(str) > 0);\n tsk_table_collection_free(&tables);\n\n /* open a file in the wrong mode */\n f = fopen(_tmp_file_name, \"w\");\n ret = tsk_table_collection_loadf(&tables, f, 0);\n ret2 = tsk_treeseq_loadf(&ts, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, ret2);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_IO);\n str = tsk_strerror(ret);\n CU_ASSERT_TRUE(strlen(str) > 0);\n CU_ASSERT_STRING_EQUAL(str, strerror(EBADF));\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n fclose(f);\n}\n\nstatic void\ntest_load_eof(void)\n{\n tsk_treeseq_t *ts = caterpillar_tree(5, 3, 3);\n tsk_table_collection_t tables;\n int ret;\n FILE *f;\n\n f = fopen(_tmp_file_name, \"w+\");\n CU_ASSERT_NOT_EQUAL(f, NULL);\n ret = tsk_table_collection_loadf(&tables, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EOF);\n fclose(f);\n tsk_table_collection_free(&tables);\n\n /* Reading an empty file also returns EOF */\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EOF);\n tsk_table_collection_free(&tables);\n\n f = fopen(_tmp_file_name, \"w+\");\n CU_ASSERT_NOT_EQUAL(f, NULL);\n ret = tsk_treeseq_dumpf(ts, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Reading from the end of the stream gives EOF */\n ret = tsk_table_collection_loadf(&tables, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EOF);\n tsk_table_collection_free(&tables);\n\n /* Reading the start of the stream is fine */\n fseek(f, 0, SEEK_SET);\n ret = tsk_table_collection_loadf(&tables, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_table_collection_free(&tables);\n\n /* And we should be back to the end of the stream */\n ret = tsk_table_collection_loadf(&tables, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EOF);\n tsk_table_collection_free(&tables);\n\n /* Trying to read the same end stream should give the same\n * result. */\n ret = tsk_table_collection_loadf(&tables, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EOF);\n tsk_table_collection_free(&tables);\n\n /* A previously init'd tables should be good too */\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_loadf(&tables, f, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EOF);\n tsk_table_collection_free(&tables);\n\n fclose(f);\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\ntest_dump_errors(void)\n{\n tsk_table_collection_t tables;\n int ret;\n FILE *f;\n const char *str;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1.0;\n\n ret = tsk_table_collection_dump(&tables, \"/\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_IO);\n str = tsk_strerror(ret);\n CU_ASSERT_TRUE(strlen(str) > 0);\n CU_ASSERT_STRING_EQUAL(str, strerror(EISDIR));\n\n /* We're assuming that we don't have write access to /bin, so don't run this\n * as root! */\n ret = tsk_table_collection_dump(&tables, \"/bin/theres_no_way_this_file_exists\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_IO);\n str = tsk_strerror(ret);\n CU_ASSERT_TRUE(strlen(str) > 0);\n CU_ASSERT_TRUE(\n (strcmp(str, strerror(EACCES)) == 0) || (strcmp(str, strerror(EPERM)) == 0));\n\n /* open a file in the wrong mode */\n f = fopen(_tmp_file_name, \"r\");\n ret = tsk_table_collection_dumpf(&tables, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_IO);\n str = tsk_strerror(ret);\n CU_ASSERT_TRUE(strlen(str) > 0);\n CU_ASSERT_STRING_EQUAL(str, strerror(EBADF));\n fclose(f);\n\n /* We'd like to catch close errors also, but it's hard to provoke them\n * without intercepting calls to fclose() */\n\n tsk_table_collection_free(&tables);\n}\n\n/* FIXME these are good tests, but we want to make them more general so that\n * they can be applied to other tables.*/\nstatic void\ntest_load_node_table_errors(void)\n{\n char format_name[TSK_FILE_FORMAT_NAME_LENGTH];\n size_t uuid_size = 36;\n char uuid[uuid_size];\n double L = 1;\n double time = 0;\n double flags = 0;\n tsk_id_t population = 0;\n tsk_id_t individual = 0;\n int8_t metadata = 0;\n uint32_t metadata_offset[] = { 0, 1 };\n uint32_t version[2]\n = { TSK_FILE_FORMAT_VERSION_MAJOR, TSK_FILE_FORMAT_VERSION_MINOR };\n write_table_col_t write_cols[] = {\n { \"nodes/time\", (void *) &time, 1, KAS_FLOAT64 },\n { \"nodes/flags\", (void *) &flags, 1, TSK_FLAGS_STORAGE_TYPE },\n { \"nodes/population\", (void *) &population, 1, TSK_ID_STORAGE_TYPE },\n { \"nodes/individual\", (void *) &individual, 1, TSK_ID_STORAGE_TYPE },\n { \"nodes/metadata\", (void *) &metadata, 1, KAS_UINT8 },\n { \"nodes/metadata_offset\", (void *) metadata_offset, 2, KAS_UINT32 },\n { \"format/name\", (void *) format_name, sizeof(format_name), KAS_INT8 },\n { \"format/version\", (void *) version, 2, KAS_UINT32 },\n { \"uuid\", (void *) uuid, uuid_size, KAS_INT8 },\n { \"sequence_length\", (void *) &L, 1, KAS_FLOAT64 },\n };\n tsk_table_collection_t tables;\n kastore_t store;\n int ret;\n\n tsk_memcpy(format_name, TSK_FILE_FORMAT_NAME, sizeof(format_name));\n /* Note: this will fail if we ever start parsing the form of the UUID */\n tsk_memset(uuid, 0, uuid_size);\n\n ret = kastore_open(&store, _tmp_file_name, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_table_cols(&store, write_cols, sizeof(write_cols) / sizeof(*write_cols));\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n /* We've only defined the format headers and nodes, so we should fail immediately\n * after with key not found */\n CU_ASSERT_FALSE(tsk_is_kas_error(ret));\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_REQUIRED_COL_NOT_FOUND);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Wrong type for time */\n write_cols[0].type = KAS_INT64;\n ret = kastore_open(&store, _tmp_file_name, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_table_cols(&store, write_cols, sizeof(write_cols) / sizeof(*write_cols));\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_COLUMN_TYPE);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_cols[0].type = KAS_FLOAT64;\n\n /* Wrong length for flags */\n write_cols[1].len = 0;\n ret = kastore_open(&store, _tmp_file_name, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_table_cols(&store, write_cols, sizeof(write_cols) / sizeof(*write_cols));\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_FILE_FORMAT);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_cols[1].len = 1;\n\n /* Wrong length for metadata offset */\n write_cols[5].len = 1;\n ret = kastore_open(&store, _tmp_file_name, \"w\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_table_cols(&store, write_cols, sizeof(write_cols) / sizeof(*write_cols));\n ret = kastore_close(&store);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_FILE_FORMAT);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n write_cols[5].len = 2;\n}\n\nstatic void\ntest_example_round_trip(void)\n{\n int ret;\n tsk_treeseq_t *ts1 = caterpillar_tree(5, 3, 3);\n tsk_treeseq_t ts2;\n tsk_table_collection_t t1, t2;\n FILE *f;\n\n ret = tsk_treeseq_copy_tables(ts1, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_dump(&t1, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n\n /* Reading multiple times into the same tables with TSK_NO_INIT is supported. */\n ret = tsk_table_collection_load(&t2, _tmp_file_name, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n tsk_table_collection_free(&t2);\n\n /* Do the same thing with treeseq API */\n remove(_tmp_file_name);\n ret = tsk_treeseq_dump(ts1, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_load(&ts2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, ts2.tables, 0));\n tsk_treeseq_free(&ts2);\n\n /* Use loadf form */\n f = fopen(_tmp_file_name, \"w+\");\n ret = tsk_table_collection_dumpf(&t1, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n fseek(f, 0, SEEK_SET);\n ret = tsk_table_collection_loadf(&t2, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n tsk_table_collection_free(&t2);\n fclose(f);\n\n /* Do the same thing with treeseq API */\n f = fopen(_tmp_file_name, \"w+\");\n ret = tsk_treeseq_dumpf(ts1, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n fseek(f, 0, SEEK_SET);\n ret = tsk_treeseq_loadf(&ts2, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, ts2.tables, 0));\n tsk_treeseq_free(&ts2);\n\n fclose(f);\n tsk_table_collection_free(&t1);\n tsk_treeseq_free(ts1);\n free(ts1);\n}\n\nstatic void\ntest_multiple_round_trip(void)\n{\n int ret;\n tsk_size_t j;\n tsk_size_t num_examples = 10;\n tsk_treeseq_t *ts;\n tsk_table_collection_t in_tables[num_examples];\n tsk_table_collection_t out_tables;\n FILE *f = fopen(_tmp_file_name, \"w+\");\n\n CU_ASSERT_NOT_EQUAL_FATAL(f, NULL);\n\n for (j = 0; j < num_examples; j++) {\n ts = caterpillar_tree(5 + j, 3 + j, 3 + j);\n ret = tsk_treeseq_copy_tables(ts, &in_tables[j], 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_dumpf(ts, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(ts);\n free(ts);\n }\n\n fseek(f, 0, SEEK_SET);\n for (j = 0; j < num_examples; j++) {\n ret = tsk_table_collection_loadf(&out_tables, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&in_tables[j], &out_tables, 0));\n tsk_table_collection_free(&out_tables);\n }\n\n /* Can do the same with the same set of previously init'd tables. */\n ret = tsk_table_collection_init(&out_tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n fseek(f, 0, SEEK_SET);\n for (j = 0; j < num_examples; j++) {\n ret = tsk_table_collection_loadf(&out_tables, f, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&in_tables[j], &out_tables, 0));\n }\n tsk_table_collection_free(&out_tables);\n\n /* Can also read until EOF to do the same thing */\n ret = tsk_table_collection_init(&out_tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n fseek(f, 0, SEEK_SET);\n j = 0;\n while (true) {\n ret = tsk_table_collection_loadf(&out_tables, f, TSK_NO_INIT);\n if (ret == TSK_ERR_EOF) {\n break;\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&in_tables[j], &out_tables, 0));\n j++;\n }\n tsk_table_collection_free(&out_tables);\n CU_ASSERT_EQUAL_FATAL(j, num_examples);\n\n for (j = 0; j < num_examples; j++) {\n tsk_table_collection_free(&in_tables[j]);\n }\n fclose(f);\n}\n\nstatic void\ntest_copy_store_drop_columns(void)\n{\n int ret;\n tsk_treeseq_t *ts = caterpillar_tree(5, 3, 3);\n tsk_table_collection_t t1, t2;\n\n ret = tsk_treeseq_copy_tables(ts, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Dropping no columns should have no effect on the data */\n copy_store_drop_columns(ts, 0, NULL, _tmp_file_name);\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n\n tsk_table_collection_free(&t1);\n tsk_table_collection_free(&t2);\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\ntest_skip_tables(void)\n{\n int ret;\n tsk_treeseq_t *ts1 = caterpillar_tree(5, 3, 3);\n tsk_treeseq_t ts2;\n tsk_table_collection_t t1, t2;\n FILE *f;\n\n ret = tsk_treeseq_dump(ts1, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&t1, _tmp_file_name, TSK_LOAD_SKIP_TABLES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, ts1->tables, TSK_CMP_IGNORE_TABLES));\n CU_ASSERT_EQUAL(t1.individuals.num_rows, 0);\n CU_ASSERT_EQUAL(t1.nodes.num_rows, 0);\n CU_ASSERT_EQUAL(t1.edges.num_rows, 0);\n CU_ASSERT_EQUAL(t1.migrations.num_rows, 0);\n CU_ASSERT_EQUAL(t1.sites.num_rows, 0);\n CU_ASSERT_EQUAL(t1.mutations.num_rows, 0);\n CU_ASSERT_EQUAL(t1.provenances.num_rows, 0);\n\n /* Test _loadf code path as well */\n f = fopen(_tmp_file_name, \"r+\");\n ret = tsk_table_collection_loadf(&t2, f, TSK_LOAD_SKIP_TABLES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n fclose(f);\n tsk_table_collection_free(&t2);\n\n /* Without TSK_LOAD_SKIP_TABLES we reach end of file */\n f = fopen(_tmp_file_name, \"r+\");\n ret = tsk_table_collection_loadf(&t2, f, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(fgetc(f), EOF);\n fclose(f);\n tsk_table_collection_free(&t2);\n\n /* Setting TSK_LOAD_SKIP_TABLES only reads part of the file */\n f = fopen(_tmp_file_name, \"r+\");\n ret = tsk_table_collection_loadf(&t2, f, TSK_LOAD_SKIP_TABLES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_NOT_EQUAL(fgetc(f), EOF);\n fclose(f);\n tsk_table_collection_free(&t2);\n\n /* We should be able to make a tree sequence */\n ret = tsk_treeseq_init(&ts2, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts2);\n\n /* Do the same thing with treeseq API */\n ret = tsk_treeseq_load(&ts2, _tmp_file_name, TSK_LOAD_SKIP_TABLES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, ts2.tables, 0));\n tsk_treeseq_free(&ts2);\n\n f = fopen(_tmp_file_name, \"r+\");\n ret = tsk_treeseq_loadf(&ts2, f, TSK_LOAD_SKIP_TABLES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, ts2.tables, 0));\n fclose(f);\n tsk_treeseq_free(&ts2);\n\n tsk_table_collection_free(&t1);\n tsk_treeseq_free(ts1);\n free(ts1);\n}\n\nstatic void\ntest_skip_reference_sequence(void)\n{\n int ret;\n tsk_treeseq_t *ts1 = caterpillar_tree(5, 3, 3);\n tsk_treeseq_t ts2;\n tsk_table_collection_t t1, t2;\n FILE *f;\n\n CU_ASSERT_TRUE(tsk_treeseq_has_reference_sequence(ts1));\n\n ret = tsk_treeseq_dump(ts1, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(\n &t1, _tmp_file_name, TSK_LOAD_SKIP_REFERENCE_SEQUENCE);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_FALSE(tsk_table_collection_equals(&t1, ts1->tables, 0));\n CU_ASSERT_TRUE(tsk_table_collection_equals(\n &t1, ts1->tables, TSK_CMP_IGNORE_REFERENCE_SEQUENCE));\n CU_ASSERT_FALSE(tsk_table_collection_has_reference_sequence(&t1));\n\n /* Test _loadf code path as well */\n f = fopen(_tmp_file_name, \"r+\");\n ret = tsk_table_collection_loadf(&t2, f, TSK_LOAD_SKIP_REFERENCE_SEQUENCE);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n fclose(f);\n tsk_table_collection_free(&t2);\n\n /* Setting TSK_LOAD_SKIP_REFERENCE_SEQUENCE only reads part of the file */\n f = fopen(_tmp_file_name, \"r+\");\n ret = tsk_table_collection_loadf(&t2, f, TSK_LOAD_SKIP_REFERENCE_SEQUENCE);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_NOT_EQUAL(fgetc(f), EOF);\n fclose(f);\n tsk_table_collection_free(&t2);\n\n /* We should be able to make a tree sequence */\n ret = tsk_treeseq_init(&ts2, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts2);\n\n /* Do the same thing with treeseq API */\n ret = tsk_treeseq_load(&ts2, _tmp_file_name, TSK_LOAD_SKIP_REFERENCE_SEQUENCE);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, ts2.tables, 0));\n tsk_treeseq_free(&ts2);\n\n f = fopen(_tmp_file_name, \"r+\");\n ret = tsk_treeseq_loadf(&ts2, f, TSK_LOAD_SKIP_REFERENCE_SEQUENCE);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, ts2.tables, 0));\n fclose(f);\n tsk_treeseq_free(&ts2);\n\n tsk_table_collection_free(&t1);\n tsk_treeseq_free(ts1);\n free(ts1);\n}\n\nint\nmain(int argc, char **argv)\n{\n CU_TestInfo tests[] = {\n { \"test_format_data_load_errors\", test_format_data_load_errors },\n { \"test_missing_indexes\", test_missing_indexes },\n { \"test_malformed_indexes\", test_malformed_indexes },\n { \"test_missing_reference_sequence\", test_missing_reference_sequence },\n { \"test_bad_column_types\", test_bad_column_types },\n { \"test_missing_required_columns\", test_missing_required_columns },\n { \"test_missing_optional_column_pairs\", test_missing_optional_column_pairs },\n { \"test_missing_required_column_pairs\", test_missing_required_column_pairs },\n { \"test_bad_offset_columns\", test_bad_offset_columns },\n { \"test_force_offset_64\", test_force_offset_64 },\n { \"test_metadata_schemas_optional\", test_metadata_schemas_optional },\n { \"test_load_node_table_errors\", test_load_node_table_errors },\n { \"test_load_bad_file_formats\", test_load_bad_file_formats },\n { \"test_load_errors\", test_load_errors },\n { \"test_load_eof\", test_load_eof },\n { \"test_dump_errors\", test_dump_errors },\n { \"test_example_round_trip\", test_example_round_trip },\n { \"test_multiple_round_trip\", test_multiple_round_trip },\n { \"test_copy_store_drop_columns\", test_copy_store_drop_columns },\n { \"test_skip_tables\", test_skip_tables },\n { \"test_skip_reference_sequence\", test_skip_reference_sequence },\n { NULL, NULL },\n };\n\n return test_main(tests, argc, argv);\n}\n"
},
{
"path": "c/tests/test_genotypes.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2022 Tskit Developers\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \"testlib.h\"\n#include \n\n#include \n#include \n#include \n\nstatic void\ntest_simplest_missing_data(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\";\n const char *sites = \"0.0 A\\n\";\n tsk_treeseq_t ts;\n tsk_vargen_t vargen;\n tsk_variant_t *var;\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, \"\", NULL, sites, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 1);\n\n ret = tsk_vargen_init(&vargen, &ts, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.0);\n CU_ASSERT_TRUE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], TSK_MISSING_DATA);\n CU_ASSERT_EQUAL(var->genotypes[1], TSK_MISSING_DATA);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_free(&vargen);\n\n ret = tsk_vargen_init(&vargen, &ts, NULL, 0, NULL, TSK_ISOLATED_NOT_MISSING);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.0);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_free(&vargen);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_missing_data_user_alleles(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\";\n const char *sites = \"0.0 A\\n\";\n tsk_treeseq_t ts;\n tsk_vargen_t vargen;\n tsk_variant_t *var;\n const char *alleles[] = { \"A\", NULL };\n int ret;\n tsk_id_t samples[] = { 0 };\n\n tsk_treeseq_from_text(&ts, 1, nodes, \"\", NULL, sites, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 1);\n\n ret = tsk_vargen_init(&vargen, &ts, NULL, 0, alleles, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.0);\n CU_ASSERT_TRUE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], TSK_MISSING_DATA);\n CU_ASSERT_EQUAL(var->genotypes[1], TSK_MISSING_DATA);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_free(&vargen);\n\n ret = tsk_vargen_init(&vargen, &ts, samples, 1, alleles, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.0);\n CU_ASSERT_TRUE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], TSK_MISSING_DATA);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_free(&vargen);\n\n ret = tsk_vargen_init(&vargen, &ts, NULL, 0, NULL, TSK_ISOLATED_NOT_MISSING);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.0);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_free(&vargen);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_missing_data_mutations(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\";\n const char *sites = \"0.0 A\\n\";\n const char *mutations = \"0 0 T -1\\n\";\n tsk_treeseq_t ts;\n tsk_vargen_t vargen;\n tsk_variant_t *var;\n const char *alleles[] = { \"A\", \"T\", NULL };\n int ret;\n tsk_id_t samples[] = { 0 };\n\n tsk_treeseq_from_text(&ts, 1, nodes, \"\", NULL, sites, mutations, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 1);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 1);\n\n ret = tsk_vargen_init(&vargen, &ts, NULL, 0, alleles, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.0);\n CU_ASSERT_TRUE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 1);\n CU_ASSERT_EQUAL(var->genotypes[1], TSK_MISSING_DATA);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_free(&vargen);\n\n ret = tsk_vargen_init(&vargen, &ts, samples, 1, alleles, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_print_state(&vargen, _devnull);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.0);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 1);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_free(&vargen);\n\n ret = tsk_vargen_init(&vargen, &ts, NULL, 0, NULL, TSK_ISOLATED_NOT_MISSING);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.0);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 1);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_free(&vargen);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_missing_data_mutations_all_samples(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\";\n const char *sites = \"0.0 A\\n\";\n const char *mutations = \"0 0 T -1\\n\"\n \"0 1 T -1\\n\";\n tsk_treeseq_t ts;\n tsk_vargen_t vargen;\n tsk_variant_t *var;\n const char *alleles[] = { \"A\", \"T\", NULL };\n int ret;\n tsk_id_t samples[] = { 0, 1 };\n\n tsk_treeseq_from_text(&ts, 1, nodes, \"\", NULL, sites, mutations, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 1);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 2);\n\n ret = tsk_vargen_init(&vargen, &ts, NULL, 0, alleles, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.0);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 1);\n CU_ASSERT_EQUAL(var->genotypes[1], 1);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_free(&vargen);\n\n ret = tsk_vargen_init(&vargen, &ts, samples, 2, alleles, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_print_state(&vargen, _devnull);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.0);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 1);\n CU_ASSERT_EQUAL(var->genotypes[1], 1);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_free(&vargen);\n\n ret = tsk_vargen_init(&vargen, &ts, NULL, 0, NULL, TSK_ISOLATED_NOT_MISSING);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.0);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 1);\n CU_ASSERT_EQUAL(var->genotypes[1], 1);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_free(&vargen);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_user_alleles(void)\n{\n int ret = 0;\n const char *sites = \"0.0 G\\n\"\n \"0.125 A\\n\"\n \"0.25 C\\n\"\n \"0.5 A\\n\";\n const char *mutations\n = \"0 0 T -1\\n\"\n \"1 1 C -1\\n\"\n \"2 0 G -1\\n\"\n \"2 1 A -1\\n\"\n \"2 2 T -1\\n\" // A bunch of different sample mutations\n \"3 4 T -1\\n\"\n \"3 0 A 5\\n\"; // A back mutation from T -> A\n tsk_treeseq_t ts;\n tsk_vargen_t vargen;\n tsk_variant_t *var;\n const char *alleles[] = { \"A\", \"C\", \"G\", \"T\", NULL };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n sites, mutations, NULL, NULL, 0);\n ret = tsk_vargen_init(&vargen, &ts, NULL, 0, alleles, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_vargen_print_state(&vargen, _devnull);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.0);\n CU_ASSERT_EQUAL_FATAL(var->num_alleles, 4);\n CU_ASSERT_EQUAL(var->allele_lengths[0], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[1], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[2], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[3], 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"A\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"C\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[2], \"G\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[3], \"T\", 1);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 3);\n CU_ASSERT_EQUAL(var->genotypes[1], 2);\n CU_ASSERT_EQUAL(var->genotypes[2], 2);\n CU_ASSERT_EQUAL(var->genotypes[3], 2);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.125);\n CU_ASSERT_EQUAL(var->num_alleles, 4);\n CU_ASSERT_EQUAL(var->allele_lengths[0], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[1], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[2], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[3], 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"A\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"C\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[2], \"G\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[3], \"T\", 1);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 1);\n CU_ASSERT_EQUAL(var->genotypes[2], 0);\n CU_ASSERT_EQUAL(var->genotypes[3], 0);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.25);\n CU_ASSERT_EQUAL(var->num_alleles, 4);\n CU_ASSERT_EQUAL(var->allele_lengths[0], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[1], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[2], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[3], 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"A\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"C\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[2], \"G\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[3], \"T\", 1);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 2);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n CU_ASSERT_EQUAL(var->genotypes[2], 3);\n CU_ASSERT_EQUAL(var->genotypes[3], 1);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.5);\n CU_ASSERT_EQUAL(var->num_alleles, 4);\n CU_ASSERT_EQUAL(var->allele_lengths[0], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[1], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[2], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[3], 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"A\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"C\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[2], \"G\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[3], \"T\", 1);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 3);\n CU_ASSERT_EQUAL(var->genotypes[2], 0);\n CU_ASSERT_EQUAL(var->genotypes[3], 0);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_vargen_free(&vargen);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_char_alphabet(void)\n{\n int ret = 0;\n const char *sites = \"0.0 A\\n\"\n \"0.125 A\\n\"\n \"0.25 C\\n\"\n \"0.5 A\\n\";\n const char *mutations\n = \"0 0 T -1\\n\"\n \"1 1 TTTAAGGG -1\\n\"\n \"2 0 G -1\\n\"\n \"2 1 AT -1\\n\"\n \"2 2 T -1\\n\" // A bunch of different sample mutations\n \"3 4 T -1\\n\"\n \"3 0 A 5\\n\"; // A back mutation from T -> A\n tsk_treeseq_t ts;\n tsk_vargen_t vargen;\n tsk_variant_t *var;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n sites, mutations, NULL, NULL, 0);\n ret = tsk_vargen_init(&vargen, &ts, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.0);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_EQUAL(var->allele_lengths[0], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[1], 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"A\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"T\", 1);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 1);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n CU_ASSERT_EQUAL(var->genotypes[2], 0);\n CU_ASSERT_EQUAL(var->genotypes[3], 0);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.125);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_EQUAL(var->allele_lengths[0], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[1], 8);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"A\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"TTTAAGGG\", 8);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 1);\n CU_ASSERT_EQUAL(var->genotypes[2], 0);\n CU_ASSERT_EQUAL(var->genotypes[3], 0);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.25);\n CU_ASSERT_EQUAL(var->num_alleles, 4);\n CU_ASSERT_EQUAL(var->allele_lengths[0], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[1], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[2], 2);\n CU_ASSERT_EQUAL(var->allele_lengths[3], 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"C\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"G\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[2], \"AT\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[3], \"T\", 1);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 1);\n CU_ASSERT_EQUAL(var->genotypes[1], 2);\n CU_ASSERT_EQUAL(var->genotypes[2], 3);\n CU_ASSERT_EQUAL(var->genotypes[3], 0);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->site.position, 0.5);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_EQUAL(var->allele_lengths[0], 1);\n CU_ASSERT_EQUAL(var->allele_lengths[1], 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"A\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"T\", 1);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 1);\n CU_ASSERT_EQUAL(var->genotypes[2], 0);\n CU_ASSERT_EQUAL(var->genotypes[3], 0);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_vargen_free(&vargen);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_binary_alphabet(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_vargen_t vargen;\n tsk_variant_t *var;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n ret = tsk_vargen_init(&vargen, &ts, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_print_state(&vargen, _devnull);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n CU_ASSERT_EQUAL(var->genotypes[2], 1);\n CU_ASSERT_EQUAL(var->genotypes[3], 0);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 0);\n CU_ASSERT_EQUAL(var->site.mutations_length, 1);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 1);\n CU_ASSERT_EQUAL(var->genotypes[2], 0);\n CU_ASSERT_EQUAL(var->genotypes[3], 0);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 1);\n CU_ASSERT_EQUAL(var->site.mutations_length, 2);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 1);\n CU_ASSERT_EQUAL(var->genotypes[1], 1);\n CU_ASSERT_EQUAL(var->genotypes[2], 1);\n CU_ASSERT_EQUAL(var->genotypes[3], 1);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 2);\n CU_ASSERT_EQUAL(var->site.mutations_length, 4);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_vargen_free(&vargen);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_non_samples(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_vargen_t vargen;\n tsk_variant_t *var;\n /* Non sample internal nodes we want to generate genotypes for */\n tsk_id_t samples[] = { 4, 5 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n ret = tsk_vargen_init(&vargen, &ts, samples, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_print_state(&vargen, _devnull);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 0);\n CU_ASSERT_EQUAL(var->site.mutations_length, 1);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n CU_ASSERT_EQUAL(var->genotypes[0], 1);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 1);\n CU_ASSERT_EQUAL(var->site.mutations_length, 2);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 2);\n CU_ASSERT_EQUAL(var->site.mutations_length, 4);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_vargen_free(&vargen);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_vargen_init(&vargen, &ts, samples, 2, NULL, TSK_ISOLATED_NOT_MISSING);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_print_state(&vargen, _devnull);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 0);\n CU_ASSERT_EQUAL(var->site.mutations_length, 1);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n CU_ASSERT_EQUAL(var->genotypes[0], 1);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 1);\n CU_ASSERT_EQUAL(var->site.mutations_length, 2);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 2);\n CU_ASSERT_EQUAL(var->site.mutations_length, 4);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_vargen_free(&vargen);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_isolated_internal_node(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_vargen_t vargen;\n tsk_variant_t *var;\n /* Two sample nodes (0,1), plus an internal non-sample node u=2 with no edges */\n const char *nodes = \"1 0 -1 -1\\n\"\n \"1 0 -1 -1\\n\"\n \"0 1 -1 -1\\n\";\n const char *sites = \"2.0 A\\n\"\n \"9.0 T\\n\";\n tsk_id_t samples[] = { 2 };\n\n tsk_treeseq_from_text(&ts, 10, nodes, \"\", NULL, sites, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tsk_treeseq_get_num_nodes(&ts), 3);\n CU_ASSERT_EQUAL_FATAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL_FATAL(tsk_treeseq_get_num_sites(&ts), 2);\n\n /* Default options (isolated_as_missing=True): internal node is isolated everywhere\n */\n ret = tsk_vargen_init(&vargen, &ts, samples, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_TRUE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], TSK_MISSING_DATA);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_TRUE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], TSK_MISSING_DATA);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_free(&vargen);\n\n /* Impute missing (isolated_as_missing=False): genotypes should be ancestral (0) */\n ret = tsk_vargen_init(&vargen, &ts, samples, 1, NULL, TSK_ISOLATED_NOT_MISSING);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_FALSE(var->has_missing_data);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_free(&vargen);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_errors(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_vargen_t vargen;\n tsk_id_t samples[] = { 0, 3 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n ret = tsk_vargen_init(&vargen, &ts, samples, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_free(&vargen);\n\n samples[0] = -1;\n ret = tsk_vargen_init(&vargen, &ts, samples, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tsk_vargen_free(&vargen);\n\n samples[0] = 7;\n ret = tsk_vargen_init(&vargen, &ts, samples, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tsk_vargen_free(&vargen);\n\n samples[0] = 3;\n ret = tsk_vargen_init(&vargen, &ts, samples, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n tsk_vargen_free(&vargen);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_user_alleles_errors(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_vargen_t vargen;\n tsk_variant_t *var;\n\n /* The maximium number of alleles is 127. We need space for one more plus the\n * sentinel */\n const char *acct_alleles[] = { \"A\", \"C\", \"G\", \"T\", NULL };\n const char *zero_allele[] = { \"0\", NULL };\n const char *no_alleles[] = { NULL };\n tsk_id_t samples[] = { 0, 3 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n\n /* these are 0/1 alleles */\n ret = tsk_vargen_init(&vargen, &ts, samples, 2, acct_alleles, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_ALLELE_NOT_FOUND);\n tsk_vargen_free(&vargen);\n\n /* pass just the 0 allele alleles at all */\n ret = tsk_vargen_init(&vargen, &ts, samples, 2, zero_allele, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_ALLELE_NOT_FOUND);\n tsk_vargen_free(&vargen);\n\n /* Empty allele list is an error */\n ret = tsk_vargen_init(&vargen, &ts, samples, 2, no_alleles, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_ZERO_ALLELES);\n tsk_vargen_free(&vargen);\n\n // for (j = 0; j < max_alleles; j++) {\n // many_alleles[j] = \"0\";\n // }\n // many_alleles[128] = NULL;\n // ret = tsk_vargen_init(&vargen, &ts, samples, 2, many_alleles, 0);\n // CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TOO_MANY_ALLELES);\n // tsk_vargen_free(&vargen);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_subsample(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_vargen_t vargen;\n tsk_variant_t *var;\n tsk_id_t samples[] = { 0, 3 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n ret = tsk_vargen_init(&vargen, &ts, samples, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_print_state(&vargen, _devnull);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 0);\n CU_ASSERT_EQUAL(var->site.mutations_length, 1);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 1);\n CU_ASSERT_EQUAL(var->site.mutations_length, 2);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 1);\n CU_ASSERT_EQUAL(var->genotypes[1], 1);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 2);\n CU_ASSERT_EQUAL(var->site.mutations_length, 4);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_vargen_free(&vargen);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Zero samples */\n ret = tsk_vargen_init(&vargen, &ts, samples, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_print_state(&vargen, _devnull);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 0);\n CU_ASSERT_EQUAL(var->site.mutations_length, 1);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 1);\n CU_ASSERT_EQUAL(var->site.mutations_length, 2);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 2);\n CU_ASSERT_EQUAL(var->site.mutations_length, 4);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_vargen_free(&vargen);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_many_alleles(void)\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_treeseq_t ts;\n tsk_vargen_t vargen;\n tsk_variant_t *var;\n tsk_size_t num_alleles = 257;\n tsk_id_t j, k;\n char alleles[num_alleles];\n tsk_table_collection_t tables;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_FATAL(ret == 0);\n tsk_treeseq_free(&ts);\n tsk_memset(alleles, 'X', (size_t) num_alleles);\n ret_id = tsk_site_table_add_row(&tables.sites, 0, \"Y\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n /* Add j mutations over a single node. */\n for (j = 0; j < (tsk_id_t) num_alleles; j++) {\n /* When j = 0 we get a parent of -1, which is the NULL_NODE */\n ret_id = tsk_mutation_table_add_row(&tables.mutations, 0, 0, j - 1,\n TSK_UNKNOWN_TIME, alleles, (tsk_size_t) j, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_vargen_init(&vargen, &ts, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_print_state(&vargen, _devnull);\n ret = tsk_vargen_next(&vargen, &var);\n /* We have j + 2 alleles. So, if j >= 126, we should fail with 8bit\n * genotypes */\n // if (j >= 126) {\n // CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TOO_MANY_ALLELES);\n // } else {\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"Y\", 1);\n for (k = 1; k < (tsk_id_t) var->num_alleles; k++) {\n CU_ASSERT_EQUAL(k - 1, (tsk_id_t) var->allele_lengths[k]);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[k], alleles, var->allele_lengths[k]);\n }\n CU_ASSERT_EQUAL(var->num_alleles, (tsk_size_t) j + 2);\n // }\n ret = tsk_vargen_free(&vargen);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_treeseq_free(&ts);\n }\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_single_tree_silent_mutations(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_vargen_t vargen;\n tsk_variant_t *var;\n\n /* Add some silent mutations */\n const char *silent_ex_sites = \"0.125 0\\n\"\n \"0.25 0\\n\"\n \"0.5 0\\n\"\n \"0.75 0\\n\";\n /* site, node, derived_state, [parent, time] */\n const char *silent_ex_mutations\n = \"0 5 0 -1\\n\" /* Silent mutation over mutation 1 */\n \"0 2 1 0\\n\"\n \"1 4 1 -1\\n\"\n \"1 0 0 2\\n\" /* Back mutation over 0 */\n \"1 0 0 3\\n\" /* Silent mutation under back mutation */\n \"2 0 1 -1\\n\" /* recurrent mutations over samples */\n \"2 1 1 -1\\n\"\n \"2 2 1 -1\\n\"\n \"2 3 1 -1\\n\"\n \"3 0 0 -1\\n\" /* Single silent mutation at a site */\n ;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n silent_ex_sites, silent_ex_mutations, NULL, NULL, 0);\n\n ret = tsk_vargen_init(&vargen, &ts, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_print_state(&vargen, _devnull);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n CU_ASSERT_EQUAL(var->genotypes[2], 1);\n CU_ASSERT_EQUAL(var->genotypes[3], 0);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 0);\n CU_ASSERT_EQUAL(var->site.mutations_length, 2);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 1);\n CU_ASSERT_EQUAL(var->genotypes[2], 0);\n CU_ASSERT_EQUAL(var->genotypes[3], 0);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 1);\n CU_ASSERT_EQUAL(var->site.mutations_length, 3);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 1);\n CU_ASSERT_EQUAL(var->genotypes[1], 1);\n CU_ASSERT_EQUAL(var->genotypes[2], 1);\n CU_ASSERT_EQUAL(var->genotypes[3], 1);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 2);\n CU_ASSERT_EQUAL(var->site.mutations_length, 4);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n CU_ASSERT_EQUAL(var->genotypes[2], 0);\n CU_ASSERT_EQUAL(var->genotypes[3], 0);\n CU_ASSERT_EQUAL(var->num_alleles, 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->site.id, 3);\n CU_ASSERT_EQUAL(var->site.mutations_length, 1);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_vargen_free(&vargen);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_multiple_variant_decode(void)\n{\n int ret = 0;\n tsk_size_t k;\n tsk_id_t s;\n tsk_treeseq_t ts;\n tsk_variant_t var;\n tsk_variant_t var_subset;\n tsk_id_t samples[] = { 0, 1, 3 };\n int32_t genos[12];\n int32_t genos_expected[] = { 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1 };\n int32_t genos_subset[9];\n int32_t genos_expected_subset[] = { 0, 0, 0, 1, 0, 0, 0, 1, 1 };\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n /* Sample subset, no sample lists */\n ret = tsk_variant_init(&var_subset, &ts, samples, 3, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (s = 0; (tsk_size_t) s < tsk_treeseq_get_num_sites(&ts); s++) {\n ret = tsk_variant_decode(&var_subset, s, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (k = 0; k < 3; ++k) {\n genos_subset[k + ((tsk_size_t) s * 3)] = var_subset.genotypes[k];\n }\n }\n CU_ASSERT_EQUAL(\n 0, memcmp(genos_subset, genos_expected_subset, sizeof(genos_expected_subset)));\n memset(genos_subset, 0, sizeof(genos_subset));\n\n /* All samples with TSK_SAMPLE_LISTS, at the same time as a subset */\n s = 0;\n ret = tsk_variant_init(&var, &ts, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (s = 0; (tsk_size_t) s < tsk_treeseq_get_num_sites(&ts); s++) {\n ret = tsk_variant_decode(&var, s, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (k = 0; k < 4; ++k) {\n genos[k + ((tsk_size_t) s * 4)] = var.genotypes[k];\n }\n ret = tsk_variant_decode(&var_subset, s, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (k = 0; k < 3; ++k) {\n genos_subset[k + ((tsk_size_t) s * 3)] = var_subset.genotypes[k];\n }\n }\n CU_ASSERT_EQUAL(\n 0, memcmp(genos_subset, genos_expected_subset, sizeof(genos_expected_subset)));\n CU_ASSERT_EQUAL(0, memcmp(genos, genos_expected, sizeof(genos_expected)));\n tsk_variant_free(&var);\n tsk_variant_free(&var_subset);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_variant_decode_errors(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_variant_t var;\n tsk_id_t bad_samples[] = { 0, 1, 32 };\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n /* Bad samples */\n ret = tsk_variant_init(&var, &ts, bad_samples, 3, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tsk_variant_free(&var);\n\n /* Site out of bounds */\n ret = tsk_variant_init(&var, &ts, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_variant_decode(&var, 42, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n tsk_variant_free(&var);\n\n tsk_treeseq_free(&ts);\n}\n\n/* Checks that the data represented by the specified pair of variants exposed\n * by the public API is equal. */\nstatic void\nassert_variants_equal(const tsk_variant_t *v1, const tsk_variant_t *v2)\n{\n tsk_size_t j;\n\n CU_ASSERT_EQUAL(v1->num_samples, v2->num_samples);\n CU_ASSERT_EQUAL(v1->num_alleles, v2->num_alleles);\n for (j = 0; j < v1->num_alleles; j++) {\n CU_ASSERT_EQUAL(v1->allele_lengths[j], v2->allele_lengths[j]);\n CU_ASSERT_EQUAL(\n 0, memcmp(v1->alleles[j], v2->alleles[j], (size_t) v1->allele_lengths[j]));\n }\n CU_ASSERT_EQUAL(v1->has_missing_data, v2->has_missing_data);\n CU_ASSERT_EQUAL(v1->num_samples, v2->num_samples);\n for (j = 0; j < v1->num_samples; j++) {\n CU_ASSERT_EQUAL(v1->samples[j], v2->samples[j]);\n CU_ASSERT_EQUAL(v1->genotypes[j], v2->genotypes[j]);\n }\n CU_ASSERT_EQUAL(v1->site.id, v2->site.id);\n CU_ASSERT_EQUAL(v1->site.position, v2->site.position);\n CU_ASSERT_EQUAL(v1->site.ancestral_state_length, v2->site.ancestral_state_length);\n CU_ASSERT_EQUAL(0, memcmp(v1->site.ancestral_state, v2->site.ancestral_state,\n (size_t) v1->site.ancestral_state_length));\n CU_ASSERT_EQUAL(v1->site.mutations_length, v2->site.mutations_length);\n /* We're pointing back to the same memory for embedded pointers */\n CU_ASSERT_EQUAL(v1->site.mutations, v2->site.mutations);\n CU_ASSERT_EQUAL(v1->site.metadata, v2->site.metadata);\n}\n\nstatic void\ntest_variant_copy(void)\n{\n int ret = 0;\n tsk_size_t j;\n tsk_treeseq_t ts;\n tsk_variant_t var, var_copy;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n ret = tsk_variant_init(&var, &ts, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = 0; j < tsk_treeseq_get_num_sites(&ts); j++) {\n ret = tsk_variant_decode(&var, (tsk_id_t) j, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_variant_restricted_copy(&var, &var_copy);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_variant_decode(&var_copy, 0, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_VARIANT_CANT_DECODE_COPY);\n\n assert_variants_equal(&var, &var_copy);\n CU_ASSERT_EQUAL(\n 0, memcmp(var.tree_sequence, var.tree_sequence, sizeof(*var.tree_sequence)));\n CU_ASSERT_EQUAL(0, memcmp(&var.tree, &var_copy.tree, sizeof(tsk_tree_t)));\n CU_ASSERT_EQUAL(0, memcmp(&var.site, &var_copy.site, sizeof(tsk_site_t)));\n CU_ASSERT_EQUAL(var_copy.traversal_stack, NULL);\n CU_ASSERT_EQUAL(var_copy.sample_index_map, NULL);\n CU_ASSERT_EQUAL(var_copy.alt_samples, NULL);\n CU_ASSERT_EQUAL(var_copy.alt_sample_index_map, NULL);\n tsk_variant_free(&var_copy);\n }\n\n tsk_variant_free(&var);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_variant_copy_long_alleles(void)\n{\n int ret = 0;\n const char *sites = \"0.0 GGGG\\n\"\n \"0.125 AAAAA\\n\"\n \"0.25 CCCCCC\\n\"\n \"0.5 AAAAAAA\\n\";\n const char *mutations = \"0 0 TTT -1\\n\"\n \"1 1 CCCCCCC -1\\n\"\n \"2 0 GGGGGGG -1\\n\"\n \"2 1 AG -1\\n\"\n \"2 2 TTTTTTT -1\\n\"\n \"3 4 TGGGGGG -1\\n\"\n \"3 0 AAA 5\\n\";\n tsk_treeseq_t ts;\n tsk_variant_t var, copy, copy_of_copy;\n tsk_size_t j;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n sites, mutations, NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_variant_init(&var, &ts, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < tsk_treeseq_get_num_sites(&ts); j++) {\n ret = tsk_variant_decode(&var, (tsk_id_t) j, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_variant_restricted_copy(&var, ©);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_variants_equal(&var, ©);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_variant_restricted_copy(©, ©_of_copy);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_variants_equal(&var, ©_of_copy);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_variant_free(©_of_copy);\n tsk_variant_free(©);\n }\n tsk_variant_free(&var);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_variant_copy_memory_management(void)\n{\n int ret = 0;\n tsk_size_t j;\n tsk_treeseq_t ts;\n tsk_variant_t *var;\n tsk_variant_t copy, copy_of_copy;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n for (j = 0; j < tsk_treeseq_get_num_sites(&ts); j++) {\n var = tsk_malloc(sizeof(*var));\n CU_ASSERT_FATAL(var != NULL);\n ret = tsk_variant_init(var, &ts, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_variant_decode(var, (tsk_id_t) j, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_variant_restricted_copy(var, ©);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_variants_equal(var, ©);\n /* Free var to make sure we're not pointing to any of the original memory. */\n tsk_variant_free(var);\n free(var);\n ret = tsk_variant_restricted_copy(©, ©_of_copy);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_variants_equal(©, ©_of_copy);\n ret = tsk_variant_decode(©, 0, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_VARIANT_CANT_DECODE_COPY);\n ret = tsk_variant_decode(©_of_copy, 0, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_VARIANT_CANT_DECODE_COPY);\n\n tsk_variant_free(©);\n tsk_variant_free(©_of_copy);\n }\n tsk_treeseq_free(&ts);\n}\n\nstatic void\nbuild_balanced_three_example_align(tsk_treeseq_t *ts)\n{\n const char *nodes = \"1 0 0 -1\\n\"\n \"1 0 0 -1\\n\"\n \"1 0 0 -1\\n\"\n \"0 1 0 -1\\n\"\n \"0 2 0 -1\\n\";\n const char *edges = \"0 10 3 1,2\\n\"\n \"0 10 4 0,3\\n\";\n const char *sites = \"2 A\\n\"\n \"9 T\\n\";\n const char *mutations = \"0 0 G\\n\"\n \"1 3 C\\n\";\n tsk_treeseq_from_text(ts, 10, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n}\n\nstatic void\ntest_alignments_basic_default(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n const char *ref = \"NNNNNNNNNN\";\n const tsk_id_t *samples;\n tsk_size_t n, L;\n char *buf;\n\n build_balanced_three_example_align(&ts);\n samples = tsk_treeseq_get_samples(&ts);\n n = tsk_treeseq_get_num_samples(&ts);\n L = 10;\n buf = tsk_malloc(n * L);\n CU_ASSERT_PTR_NOT_NULL_FATAL(buf);\n\n ret = tsk_treeseq_decode_alignments(\n &ts, ref, (tsk_size_t) strlen(ref), samples, n, 0, 10, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_NSTRING_EQUAL(buf + 0 * L, \"NNGNNNNNNT\", L);\n CU_ASSERT_NSTRING_EQUAL(buf + 1 * L, \"NNANNNNNNC\", L);\n CU_ASSERT_NSTRING_EQUAL(buf + 2 * L, \"NNANNNNNNC\", L);\n\n tsk_safe_free(buf);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_reference_sequence(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n const char *ref = \"0123456789\";\n const tsk_id_t *samples;\n tsk_size_t n, L = 10;\n char *buf = NULL;\n\n build_balanced_three_example_align(&ts);\n samples = tsk_treeseq_get_samples(&ts);\n n = tsk_treeseq_get_num_samples(&ts);\n buf = tsk_malloc(n * L);\n CU_ASSERT_PTR_NOT_NULL_FATAL(buf);\n\n ret = tsk_treeseq_decode_alignments(\n &ts, ref, (tsk_size_t) strlen(ref), samples, n, 0, 10, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_NSTRING_EQUAL(buf + 0 * L, \"01G345678T\", L);\n CU_ASSERT_NSTRING_EQUAL(buf + 1 * L, \"01A345678C\", L);\n CU_ASSERT_NSTRING_EQUAL(buf + 2 * L, \"01A345678C\", L);\n\n tsk_safe_free(buf);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_partial_isolation(void)\n{\n int ret = 0;\n const char *nodes = \"0 1 0 -1\\n\" /* parent */\n \"1 0 0 -1\\n\"; /* child sample */\n const char *edges = \"3 7 0 1\\n\";\n const char *sites = \"5 A\\n\";\n const char *mutations = \"0 1 G\\n\";\n tsk_treeseq_t ts;\n const char *ref = \"0123456789\";\n tsk_id_t node = 1;\n char buf[10];\n\n tsk_treeseq_from_text(&ts, 10, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n ret = tsk_treeseq_decode_alignments(&ts, ref, 10, &node, 1, 0, 10, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_NSTRING_EQUAL(buf, \"NNN34G6NNN\", 10);\n\n ret = tsk_treeseq_decode_alignments(&ts, ref, 10, &node, 1, 2, 8, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_NSTRING_EQUAL(buf, \"N34G6N\", 6);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_return_code_truncated_interval(void)\n{\n int ret = 0;\n const char *nodes = \"1 0 0 -1\\n\"\n \"1 0 0 -1\\n\"\n \"0 1 0 -1\\n\";\n /* Tree over [0,5): samples 0 and 1 under root 2.\n * Tree over [5,10): only sample 1 under root 2 (sample 0 isolated). */\n const char *edges = \"0 5 2 0\\n\"\n \"0 10 2 1\\n\";\n tsk_treeseq_t ts;\n const tsk_id_t *samples;\n tsk_size_t n;\n char buf[10];\n const char *ref = \"NNNNNNNNNN\";\n\n tsk_treeseq_from_text(&ts, 10, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n samples = tsk_treeseq_get_samples(&ts);\n n = tsk_treeseq_get_num_samples(&ts);\n\n ret = tsk_treeseq_decode_alignments(&ts, ref, 10, samples, n, 0, 5, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_NSTRING_EQUAL(buf + 0 * 5, \"NNNNN\", 5);\n CU_ASSERT_NSTRING_EQUAL(buf + 1 * 5, \"NNNNN\", 5);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_invalid_allele_length(void)\n{\n int ret = 0;\n const char *nodes = \"1 0 0 -1\\n\";\n const char *edges = \"\";\n const char *sites = \"2 AC\\n\";\n tsk_treeseq_t ts;\n tsk_id_t node = 0;\n char buf[5];\n const char *ref = \"NNNNN\";\n\n tsk_treeseq_from_text(&ts, 5, nodes, edges, NULL, sites, NULL, NULL, NULL, 0);\n ret = tsk_treeseq_decode_alignments(&ts, ref, 5, &node, 1, 0, 5, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_ALLELE_LENGTH);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_bad_reference_length(void)\n{\n int ret = 0;\n const char *nodes = \"1 0 0 -1\\n\";\n const char *edges = \"\";\n tsk_treeseq_t ts;\n tsk_id_t node = 0;\n char buf[5];\n const char *ref = \"NNNNN\";\n\n tsk_treeseq_from_text(&ts, 5, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_treeseq_decode_alignments(&ts, ref, 4, &node, 1, 0, 5, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_non_integer_bounds(void)\n{\n int ret = 0;\n const char *nodes = \"1 0 0 -1\\n\";\n const char *edges = \"\";\n tsk_treeseq_t ts;\n tsk_id_t node = 0;\n char buf[5];\n const char *ref = \"NNNNN\";\n\n tsk_treeseq_from_text(&ts, 5, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_treeseq_decode_alignments(&ts, ref, 5, &node, 1, 0.5, 5, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_discrete_genome_required(void)\n{\n int ret = 0;\n const char *nodes = \"1 0 0 -1\\n\";\n const char *edges = \"\";\n const char *sites = \"0.5 A\\n\";\n tsk_treeseq_t ts;\n tsk_id_t node = 0;\n char buf[5];\n const char *ref = \"NNNNN\";\n\n tsk_treeseq_from_text(&ts, 5, nodes, edges, NULL, sites, NULL, NULL, NULL, 0);\n ret = tsk_treeseq_decode_alignments(&ts, ref, 5, &node, 1, 0, 5, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_null_reference(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n const tsk_id_t *samples;\n tsk_size_t n;\n char buf[10];\n\n build_balanced_three_example_align(&ts);\n samples = tsk_treeseq_get_samples(&ts);\n n = tsk_treeseq_get_num_samples(&ts);\n\n ret = tsk_treeseq_decode_alignments(&ts, NULL, 10, samples, n, 0, 10, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_null_nodes_or_buf(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n const char *ref = \"NNNNNNNNNN\";\n const tsk_id_t *samples;\n tsk_size_t n;\n char buf[30];\n\n build_balanced_three_example_align(&ts);\n samples = tsk_treeseq_get_samples(&ts);\n n = tsk_treeseq_get_num_samples(&ts);\n\n ret = tsk_treeseq_decode_alignments(&ts, ref, 10, NULL, n, 0, 10, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n ret = tsk_treeseq_decode_alignments(&ts, ref, 10, samples, n, 0, 10, 'N', NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_node_out_of_bounds(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n const char *ref = \"NNNNNNNNNN\";\n tsk_id_t bad_node;\n char buf[10];\n\n build_balanced_three_example_align(&ts);\n bad_node = (tsk_id_t) tsk_treeseq_get_num_nodes(&ts);\n\n ret = tsk_treeseq_decode_alignments(&ts, ref, 10, &bad_node, 1, 0, 10, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_isolated_as_not_missing(void)\n{\n int ret = 0;\n const char *nodes = \"0 1 0 -1\\n\" /* parent */\n \"1 0 0 -1\\n\"; /* child sample */\n const char *edges = \"3 7 0 1\\n\";\n const char *sites = \"5 A\\n\";\n const char *mutations = \"0 1 G\\n\";\n tsk_treeseq_t ts;\n const char *ref = \"0123456789\";\n tsk_id_t node = 1;\n char buf[10];\n\n tsk_treeseq_from_text(&ts, 10, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n ret = tsk_treeseq_decode_alignments(\n &ts, ref, 10, &node, 1, 0, 10, 'N', buf, TSK_ISOLATED_NOT_MISSING);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_NSTRING_EQUAL(buf, \"01234G6789\", 10);\n\n ret = tsk_treeseq_decode_alignments(\n &ts, ref, 10, &node, 1, 2, 8, 'N', buf, TSK_ISOLATED_NOT_MISSING);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_NSTRING_EQUAL(buf, \"234G67\", 6);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_internal_node_non_sample(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n const char *ref = \"NNNNNNNNNN\";\n tsk_id_t node = 3; /* internal node */\n char buf[10];\n\n build_balanced_three_example_align(&ts);\n ret = tsk_treeseq_decode_alignments(&ts, ref, 10, &node, 1, 0, 10, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_NSTRING_EQUAL(buf, \"NNANNNNNNC\", 10);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_missing_char_collision(void)\n{\n int ret = 0;\n const char *nodes = \"1 0 0 -1\\n\";\n const char *edges = \"\";\n const char *sites = \"2 A\\n\";\n const char *mutations = \"0 0 Q\\n\"; /* allele equals missing char */\n tsk_treeseq_t ts;\n tsk_id_t node = 0;\n char buf[5];\n const char *ref = \"NNNNN\";\n\n tsk_treeseq_from_text(&ts, 5, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n ret = tsk_treeseq_decode_alignments(&ts, ref, 5, &node, 1, 0, 5, 'Q', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MISSING_CHAR_COLLISION);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_zero_nodes_ok(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n const char *ref = \"NNNNNNNNNN\";\n build_balanced_three_example_align(&ts);\n ret = tsk_treeseq_decode_alignments(&ts, ref, 10, NULL, 0, 0, 10, 'N', NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_bad_bounds_cases(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n const char *ref = \"NNNNNNNNNN\";\n tsk_id_t node = 0;\n char buf[1];\n build_balanced_three_example_align(&ts);\n /* left == right invalid */\n ret = tsk_treeseq_decode_alignments(&ts, ref, 10, &node, 1, 5, 5, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n /* left negative */\n ret = tsk_treeseq_decode_alignments(&ts, ref, 10, &node, 1, -1, 5, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_order_preserved(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n const char *ref = \"NNNNNNNNNN\";\n tsk_id_t nodes_arr[3];\n char buf[30];\n tsk_size_t L = 10;\n\n build_balanced_three_example_align(&ts);\n nodes_arr[0] = 2;\n nodes_arr[1] = 0;\n nodes_arr[2] = 1;\n ret = tsk_treeseq_decode_alignments(&ts, ref, 10, nodes_arr, 3, 0, 10, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_NSTRING_EQUAL(buf + 0 * L, \"NNANNNNNNC\", L);\n CU_ASSERT_NSTRING_EQUAL(buf + 1 * L, \"NNGNNNNNNT\", L);\n CU_ASSERT_NSTRING_EQUAL(buf + 2 * L, \"NNANNNNNNC\", L);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_missing_char_custom(void)\n{\n int ret = 0;\n const char *nodes = \"0 1 0 -1\\n\" /* parent */\n \"1 0 0 -1\\n\"; /* child sample */\n const char *edges = \"3 7 0 1\\n\";\n const char *sites = \"5 A\\n\";\n const char *mutations = \"0 1 G\\n\";\n tsk_treeseq_t ts;\n const char *ref = \"0123456789\";\n tsk_id_t node = 1;\n char buf[10];\n\n tsk_treeseq_from_text(&ts, 10, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n ret = tsk_treeseq_decode_alignments(&ts, ref, 10, &node, 1, 0, 10, 'Q', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_NSTRING_EQUAL(buf, \"QQQ34G6QQQ\", 10);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_embedded_null_reference(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n char ref[10] = { '0', '1', '2', '3', '\\0', '5', '6', '7', '8', '9' };\n const tsk_id_t *samples;\n tsk_size_t n, L = 10;\n char *buf = NULL;\n char exp0[10] = { '0', '1', 'G', '3', '\\0', '5', '6', '7', '8', 'T' };\n char exp1[10] = { '0', '1', 'A', '3', '\\0', '5', '6', '7', '8', 'C' };\n char exp2[10] = { '0', '1', 'A', '3', '\\0', '5', '6', '7', '8', 'C' };\n\n build_balanced_three_example_align(&ts);\n samples = tsk_treeseq_get_samples(&ts);\n n = tsk_treeseq_get_num_samples(&ts);\n buf = tsk_malloc(n * L);\n CU_ASSERT_PTR_NOT_NULL_FATAL(buf);\n\n ret = tsk_treeseq_decode_alignments(&ts, ref, 10, samples, n, 0, 10, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(0, memcmp(buf + 0 * L, exp0, (size_t) L));\n CU_ASSERT_EQUAL(0, memcmp(buf + 1 * L, exp1, (size_t) L));\n CU_ASSERT_EQUAL(0, memcmp(buf + 2 * L, exp2, (size_t) L));\n tsk_safe_free(buf);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_alignments_growing_allele_buffer(void)\n{\n /* Verify we handle sites with increasing allele counts without per-site realloc\n * churn. */\n int ret = 0;\n /* Two samples (0,1) with root 2 over [0,3). */\n const char *nodes = \"1 0 0 -1\\n\"\n \"1 0 0 -1\\n\"\n \"0 1 0 -1\\n\";\n const char *edges = \"0 3 2 0\\n\"\n \"0 3 2 1\\n\";\n /* Sites: pos 1 ancestral A; pos 2 ancestral A. */\n const char *sites = \"1 A\\n\"\n \"2 A\\n\";\n /* Mutations: at site 0 (pos 1) node 0 -> G (2 alleles total).\n * at site 1 (pos 2) node 0 -> C and node 1 -> T (3 alleles total). */\n const char *mutations = \"0 0 G\\n\"\n \"1 0 C\\n\"\n \"1 1 T\\n\";\n\n tsk_treeseq_t ts;\n const char *ref = \"NNN\";\n const tsk_id_t *samples;\n tsk_size_t n, L = 3;\n char *buf = NULL;\n\n tsk_treeseq_from_text(&ts, 3, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n samples = tsk_treeseq_get_samples(&ts);\n n = tsk_treeseq_get_num_samples(&ts);\n buf = tsk_malloc(n * L);\n CU_ASSERT_PTR_NOT_NULL_FATAL(buf);\n\n ret = tsk_treeseq_decode_alignments(&ts, ref, 3, samples, n, 0, 3, 'N', buf, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Expected: sample 0 -> NGC; sample 1 -> NAT */\n CU_ASSERT_NSTRING_EQUAL(buf + 0 * L, \"NGC\", L);\n CU_ASSERT_NSTRING_EQUAL(buf + 1 * L, \"NAT\", L);\n\n tsk_safe_free(buf);\n tsk_treeseq_free(&ts);\n}\nint\nmain(int argc, char **argv)\n{\n CU_TestInfo tests[] = {\n { \"test_simplest_missing_data\", test_simplest_missing_data },\n { \"test_simplest_missing_data_user_alleles\",\n test_simplest_missing_data_user_alleles },\n { \"test_simplest_missing_data_mutations\", test_simplest_missing_data_mutations },\n { \"test_simplest_missing_data_mutations_all_samples\",\n test_simplest_missing_data_mutations_all_samples },\n { \"test_single_tree_user_alleles\", test_single_tree_user_alleles },\n { \"test_single_tree_char_alphabet\", test_single_tree_char_alphabet },\n { \"test_single_tree_binary_alphabet\", test_single_tree_binary_alphabet },\n { \"test_single_tree_non_samples\", test_single_tree_non_samples },\n { \"test_isolated_internal_node\", test_isolated_internal_node },\n { \"test_single_tree_errors\", test_single_tree_errors },\n { \"test_single_tree_user_alleles_errors\", test_single_tree_user_alleles_errors },\n { \"test_single_tree_subsample\", test_single_tree_subsample },\n { \"test_single_tree_many_alleles\", test_single_tree_many_alleles },\n { \"test_single_tree_silent_mutations\", test_single_tree_silent_mutations },\n { \"test_multiple_variant_decode\", test_multiple_variant_decode },\n { \"test_variant_decode_errors\", test_variant_decode_errors },\n { \"test_variant_copy\", test_variant_copy },\n { \"test_variant_copy_long_alleles\", test_variant_copy_long_alleles },\n { \"test_variant_copy_memory_management\", test_variant_copy_memory_management },\n { \"test_alignments_basic_default\", test_alignments_basic_default },\n { \"test_alignments_reference_sequence\", test_alignments_reference_sequence },\n { \"test_alignments_partial_isolation\", test_alignments_partial_isolation },\n { \"test_alignments_return_code_truncated_interval\",\n test_alignments_return_code_truncated_interval },\n { \"test_alignments_isolated_as_not_missing\",\n test_alignments_isolated_as_not_missing },\n { \"test_alignments_internal_node_non_sample\",\n test_alignments_internal_node_non_sample },\n { \"test_alignments_invalid_allele_length\",\n test_alignments_invalid_allele_length },\n { \"test_alignments_bad_reference_length\", test_alignments_bad_reference_length },\n { \"test_alignments_non_integer_bounds\", test_alignments_non_integer_bounds },\n { \"test_alignments_discrete_genome_required\",\n test_alignments_discrete_genome_required },\n { \"test_alignments_null_reference\", test_alignments_null_reference },\n { \"test_alignments_null_nodes_or_buf\", test_alignments_null_nodes_or_buf },\n { \"test_alignments_node_out_of_bounds\", test_alignments_node_out_of_bounds },\n { \"test_alignments_missing_char_collision\",\n test_alignments_missing_char_collision },\n { \"test_alignments_zero_nodes_ok\", test_alignments_zero_nodes_ok },\n { \"test_alignments_bad_bounds_cases\", test_alignments_bad_bounds_cases },\n { \"test_alignments_order_preserved\", test_alignments_order_preserved },\n { \"test_alignments_missing_char_custom\", test_alignments_missing_char_custom },\n { \"test_alignments_embedded_null_reference\",\n test_alignments_embedded_null_reference },\n { \"test_alignments_growing_allele_buffer\",\n test_alignments_growing_allele_buffer },\n { NULL, NULL },\n };\n\n return test_main(tests, argc, argv);\n}\n"
},
{
"path": "c/tests/test_haplotype_matching.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2023 Tskit Developers\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \"testlib.h\"\n#include \n\n#include \n#include \n\nstatic void\ntest_single_tree_missing_alleles(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_ls_hmm_t ls_hmm;\n tsk_compressed_matrix_t forward;\n tsk_viterbi_matrix_t viterbi;\n\n double rho[] = { 0, 0.25, 0.25 };\n double mu[] = { 0.125, 0.125, 0.125 };\n int32_t h[] = { 0, 0, 0, 0 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n\n ret = tsk_ls_hmm_init(&ls_hmm, &ts, rho, mu, TSK_ALLELES_ACGT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_ls_hmm_forward(&ls_hmm, h, &forward, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_ALLELE_NOT_FOUND);\n ret = tsk_ls_hmm_viterbi(&ls_hmm, h, &viterbi, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_ALLELE_NOT_FOUND);\n\n tsk_ls_hmm_free(&ls_hmm);\n tsk_compressed_matrix_free(&forward);\n tsk_viterbi_matrix_free(&viterbi);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_exact_match(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_ls_hmm_t ls_hmm;\n tsk_compressed_matrix_t forward;\n tsk_viterbi_matrix_t viterbi;\n\n double rho[] = { 0.0, 0.25, 0.25 };\n double mu[] = { 0, 0, 0 };\n int32_t h[] = { 1, 1, 1 };\n tsk_id_t path[3];\n double decoded_compressed_matrix[12];\n unsigned int precision;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n\n ret = tsk_ls_hmm_init(&ls_hmm, &ts, rho, mu, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_ls_hmm_forward(&ls_hmm, h, &forward, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_compressed_matrix_print_state(&forward, _devnull);\n tsk_ls_hmm_print_state(&ls_hmm, _devnull);\n ret = tsk_compressed_matrix_decode(&forward, decoded_compressed_matrix);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_ls_hmm_viterbi(&ls_hmm, h, &viterbi, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_viterbi_matrix_print_state(&viterbi, _devnull);\n tsk_ls_hmm_print_state(&ls_hmm, _devnull);\n ret = tsk_viterbi_matrix_traceback(&viterbi, path, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(path[0], 2);\n CU_ASSERT_EQUAL(path[1], 1);\n CU_ASSERT_EQUAL(path[2], 1);\n\n /* Should get the same answer at lower precision */\n for (precision = 1; precision < 24; precision++) {\n ret = tsk_ls_hmm_set_precision(&ls_hmm, precision);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_ls_hmm_viterbi(&ls_hmm, h, &viterbi, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_viterbi_matrix_print_state(&viterbi, _devnull);\n tsk_ls_hmm_print_state(&ls_hmm, _devnull);\n ret = tsk_viterbi_matrix_traceback(&viterbi, path, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(path[0], 2);\n CU_ASSERT_EQUAL(path[1], 1);\n CU_ASSERT_EQUAL(path[2], 1);\n }\n\n tsk_ls_hmm_free(&ls_hmm);\n tsk_compressed_matrix_free(&forward);\n tsk_viterbi_matrix_free(&viterbi);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_missing_haplotype_data(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_ls_hmm_t ls_hmm;\n tsk_compressed_matrix_t forward;\n tsk_viterbi_matrix_t viterbi;\n\n double rho[] = { 0.0, 0.25, 0.25 };\n double mu[] = { 0, 0, 0 };\n int32_t h[] = { 1, TSK_MISSING_DATA, 1 };\n tsk_id_t path[3];\n double decoded_compressed_matrix[12];\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n\n ret = tsk_ls_hmm_init(&ls_hmm, &ts, rho, mu, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_ls_hmm_forward(&ls_hmm, h, &forward, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_compressed_matrix_print_state(&forward, _devnull);\n tsk_ls_hmm_print_state(&ls_hmm, _devnull);\n ret = tsk_compressed_matrix_decode(&forward, decoded_compressed_matrix);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_ls_hmm_viterbi(&ls_hmm, h, &viterbi, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_viterbi_matrix_print_state(&viterbi, _devnull);\n tsk_ls_hmm_print_state(&ls_hmm, _devnull);\n ret = tsk_viterbi_matrix_traceback(&viterbi, path, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(path[0], 2);\n CU_ASSERT_EQUAL(path[1], 2);\n CU_ASSERT_EQUAL(path[2], 2);\n\n tsk_ls_hmm_free(&ls_hmm);\n tsk_compressed_matrix_free(&forward);\n tsk_viterbi_matrix_free(&viterbi);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_match_impossible(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_ls_hmm_t ls_hmm;\n tsk_compressed_matrix_t forward;\n tsk_compressed_matrix_t backward;\n tsk_viterbi_matrix_t viterbi;\n\n double rho[] = { 0.0, 0.25, 0.25 };\n double mu[] = { 0, 0, 0 };\n /* This haplotype can't happen with a mutation rate of 0 */\n int32_t h[] = { 0, 0, 0 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n\n ret = tsk_ls_hmm_init(&ls_hmm, &ts, rho, mu, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_ls_hmm_forward(&ls_hmm, h, &forward, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MATCH_IMPOSSIBLE);\n tsk_compressed_matrix_print_state(&forward, _devnull);\n tsk_ls_hmm_print_state(&ls_hmm, _devnull);\n\n ret = tsk_ls_hmm_viterbi(&ls_hmm, h, &viterbi, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MATCH_IMPOSSIBLE);\n tsk_viterbi_matrix_print_state(&viterbi, _devnull);\n tsk_ls_hmm_print_state(&ls_hmm, _devnull);\n\n ret = tsk_ls_hmm_backward(&ls_hmm, h, forward.normalisation_factor, &backward, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MATCH_IMPOSSIBLE);\n tsk_compressed_matrix_print_state(&backward, _devnull);\n /* tsk_compressed_matrix_print_state(&forward, stdout); */\n /* tsk_compressed_matrix_print_state(&backward, stdout); */\n tsk_ls_hmm_print_state(&ls_hmm, _devnull);\n\n tsk_ls_hmm_free(&ls_hmm);\n tsk_compressed_matrix_free(&forward);\n tsk_compressed_matrix_free(&backward);\n tsk_viterbi_matrix_free(&viterbi);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_errors(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_ls_hmm_t ls_hmm;\n tsk_compressed_matrix_t forward;\n tsk_viterbi_matrix_t viterbi;\n tsk_value_transition_t T[1];\n double decoded[3][4];\n\n double rho[] = { 0.0, 0.25, 0.25 };\n double mu[] = { 0, 0, 0 };\n int32_t h[] = { 0, 0, 0 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n\n ret = tsk_viterbi_matrix_init(&viterbi, &ts, 0, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_compressed_matrix_init(&forward, &ts, 0, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_ls_hmm_init(&ls_hmm, &ts, rho, mu, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n viterbi.matrix.tree_sequence = NULL;\n ret = tsk_ls_hmm_viterbi(&ls_hmm, h, &viterbi, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n viterbi.matrix.tree_sequence = &ts;\n\n forward.tree_sequence = NULL;\n ret = tsk_ls_hmm_forward(&ls_hmm, h, &forward, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n forward.tree_sequence = &ts;\n\n ret = tsk_compressed_matrix_store_site(&forward, 3, 0, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n ret = tsk_compressed_matrix_store_site(&forward, 4, 0, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n\n /* FIXME disabling this tests for now because we filter out negative\n * nodes when storing now, to accomodate some oddness in the initial\n * conditions of the backward matrix. */\n /* T[0].tree_node = -1; */\n /* T[0].value = 0; */\n /* ret = tsk_compressed_matrix_store_site(&forward, 0, 1, 1, T); */\n /* CU_ASSERT_EQUAL_FATAL(ret, 0); */\n /* ret = tsk_compressed_matrix_decode(&forward, (double *) decoded); */\n /* CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS); */\n\n T[0].tree_node = 7;\n T[0].value = 0;\n ret = tsk_compressed_matrix_store_site(&forward, 0, 1, 1, T);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_compressed_matrix_decode(&forward, (double *) decoded);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n tsk_ls_hmm_free(&ls_hmm);\n tsk_compressed_matrix_free(&forward);\n tsk_viterbi_matrix_free(&viterbi);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_compressed_matrix(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_compressed_matrix_t matrix;\n tsk_ls_hmm_t ls_hmm;\n tsk_size_t max_transitions = 1024;\n tsk_value_transition_t T[max_transitions];\n double decoded[3][4];\n int j;\n\n double rho[] = { 0.0, 0.25, 0.25 };\n double mu[] = { 0.1, 0.1, 0.1 };\n int32_t h[] = { 0, 0, 0 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n\n ret = tsk_compressed_matrix_init(&matrix, &ts, 0, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_compressed_matrix_print_state(&matrix, _devnull);\n\n T[0].tree_node = 6;\n T[0].value = 0;\n for (j = 0; j < 3; j++) {\n T[1].tree_node = j;\n T[1].value = 1;\n ret = tsk_compressed_matrix_store_site(&matrix, j, 1.0, 2, T);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n }\n tsk_compressed_matrix_print_state(&matrix, _devnull);\n\n ret = tsk_compressed_matrix_decode(&matrix, (double *) decoded);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(decoded[0][0], 1.0);\n CU_ASSERT_EQUAL(decoded[0][1], 0.0);\n CU_ASSERT_EQUAL(decoded[0][2], 0.0);\n CU_ASSERT_EQUAL(decoded[1][0], 0.0);\n CU_ASSERT_EQUAL(decoded[1][1], 1.0);\n CU_ASSERT_EQUAL(decoded[1][2], 0.0);\n CU_ASSERT_EQUAL(decoded[2][0], 0.0);\n CU_ASSERT_EQUAL(decoded[2][1], 0.0);\n CU_ASSERT_EQUAL(decoded[2][2], 1.0);\n\n /* Cleared matrix should be zero everywhere */\n tsk_compressed_matrix_clear(&matrix);\n ret = tsk_compressed_matrix_decode(&matrix, (double *) decoded);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < 3; j++) {\n CU_ASSERT_EQUAL(decoded[j][0], 0.0);\n CU_ASSERT_EQUAL(decoded[j][1], 0.0);\n CU_ASSERT_EQUAL(decoded[j][2], 0.0);\n }\n\n ret = tsk_ls_hmm_init(&ls_hmm, &ts, rho, mu, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_ls_hmm_forward(&ls_hmm, h, &matrix, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_compressed_matrix_print_state(&matrix, _devnull);\n ret = tsk_compressed_matrix_decode(&matrix, (double *) decoded);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_compressed_matrix_free(&matrix);\n tsk_ls_hmm_free(&ls_hmm);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_viterbi_matrix(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_viterbi_matrix_t viterbi;\n tsk_ls_hmm_t ls_hmm;\n double rho[] = { 0.0, 0.25, 0.25 };\n double mu[] = { 0, 0, 0 };\n int32_t h[] = { 1, 1, 1 };\n tsk_id_t path[3];\n tsk_value_transition_t T[2];\n int j;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n\n ret = tsk_viterbi_matrix_init(&viterbi, &ts, 0, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_viterbi_matrix_print_state(&viterbi, _devnull);\n ret = tsk_viterbi_matrix_traceback(&viterbi, path, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NULL_VITERBI_MATRIX);\n\n T[0].tree_node = 6;\n T[0].value = 0;\n T[1].tree_node = 1;\n T[1].value = 1;\n for (j = 0; j < 3; j++) {\n ret = tsk_compressed_matrix_store_site(&viterbi.matrix, j, 1.0, 2, T);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* We need to have one record per site, so we put in a record\n * at the root saying we don't need to recombine */\n ret = tsk_viterbi_matrix_add_recombination_required(&viterbi, j, 6, false);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n }\n ret = tsk_viterbi_matrix_traceback(&viterbi, path, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(path[0], 1);\n CU_ASSERT_EQUAL_FATAL(path[1], 1);\n CU_ASSERT_EQUAL_FATAL(path[2], 1);\n\n ret = tsk_ls_hmm_init(&ls_hmm, &ts, rho, mu, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_ls_hmm_viterbi(&ls_hmm, h, &viterbi, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_viterbi_matrix_print_state(&viterbi, _devnull);\n ret = tsk_viterbi_matrix_traceback(&viterbi, path, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_viterbi_matrix_clear(&viterbi);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_viterbi_matrix_traceback(&viterbi, path, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NULL_VITERBI_MATRIX);\n\n tsk_viterbi_matrix_free(&viterbi);\n\n ret = tsk_viterbi_matrix_init(&viterbi, &ts, 1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Make sure we hit the realloc case for recombination records */\n for (j = 0; j < 100; j++) {\n ret = tsk_viterbi_matrix_add_recombination_required(&viterbi, 0, 6, false);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n }\n tsk_viterbi_matrix_print_state(&viterbi, _devnull);\n\n tsk_viterbi_matrix_free(&viterbi);\n tsk_ls_hmm_free(&ls_hmm);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_multi_tree_exact_match(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_ls_hmm_t ls_hmm;\n tsk_compressed_matrix_t forward, backward;\n tsk_viterbi_matrix_t viterbi;\n\n double rho[] = { 0.0, 0.25, 0.25 };\n double mu[] = { 0, 0, 0 };\n int32_t h[] = { 1, 1, 1 };\n tsk_id_t path[3];\n double decoded_compressed_matrix[12];\n unsigned int precision;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n ret = tsk_ls_hmm_init(&ls_hmm, &ts, rho, mu, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_ls_hmm_forward(&ls_hmm, h, &forward, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_ls_hmm_print_state(&ls_hmm, _devnull);\n tsk_compressed_matrix_print_state(&forward, _devnull);\n ret = tsk_compressed_matrix_decode(&forward, decoded_compressed_matrix);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_ls_hmm_backward(&ls_hmm, h, forward.normalisation_factor, &backward, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_ls_hmm_print_state(&ls_hmm, _devnull);\n tsk_compressed_matrix_print_state(&backward, _devnull);\n ret = tsk_compressed_matrix_decode(&backward, decoded_compressed_matrix);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_ls_hmm_viterbi(&ls_hmm, h, &viterbi, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_viterbi_matrix_print_state(&viterbi, _devnull);\n tsk_ls_hmm_print_state(&ls_hmm, _devnull);\n ret = tsk_viterbi_matrix_traceback(&viterbi, path, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(path[0], 2);\n CU_ASSERT_EQUAL(path[1], 0);\n CU_ASSERT_EQUAL(path[2], 1);\n\n /* Should get the same answer at lower precision */\n for (precision = 4; precision < 24; precision++) {\n ret = tsk_ls_hmm_set_precision(&ls_hmm, precision);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_ls_hmm_viterbi(&ls_hmm, h, &viterbi, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_viterbi_matrix_print_state(&viterbi, _devnull);\n tsk_ls_hmm_print_state(&ls_hmm, _devnull);\n ret = tsk_viterbi_matrix_traceback(&viterbi, path, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(path[0], 2);\n CU_ASSERT_EQUAL(path[1], 0);\n CU_ASSERT_EQUAL(path[2], 1);\n }\n\n tsk_ls_hmm_free(&ls_hmm);\n tsk_compressed_matrix_free(&forward);\n tsk_compressed_matrix_free(&backward);\n tsk_viterbi_matrix_free(&viterbi);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_multi_tree_errors(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_compressed_matrix_t forward;\n tsk_value_transition_t T[1];\n double decoded[3][4];\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n ret = tsk_compressed_matrix_init(&forward, &ts, 0, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* We want a tree node that is not in the first tree */\n T[0].tree_node = 7;\n T[0].value = 0;\n ret = tsk_compressed_matrix_store_site(&forward, 0, 1, 1, T);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_compressed_matrix_decode(&forward, (double *) decoded);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_COMPRESSED_MATRIX_NODE);\n\n tsk_compressed_matrix_free(&forward);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_caterpillar_tree_many_values(void)\n{\n int ret = 0;\n tsk_ls_hmm_t ls_hmm;\n tsk_compressed_matrix_t matrix;\n double rho[] = { 0.1, 0.1, 0.1, 0.1, 0.1 };\n double mu[] = { 0.0, 0.0, 0.0, 0.0, 0.0 };\n int32_t h[] = { 0, 0, 0, 0, 0 };\n tsk_size_t n[] = {\n 8,\n 16,\n 32,\n 64,\n };\n tsk_treeseq_t *ts;\n tsk_size_t j;\n\n for (j = 0; j < sizeof(n) / sizeof(*n); j++) {\n ts = caterpillar_tree(n[j], 5, n[j] - 2);\n ret = tsk_ls_hmm_init(&ls_hmm, ts, rho, mu, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_compressed_matrix_init(&matrix, ts, 1 << 10, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_ls_hmm_forward(&ls_hmm, h, &matrix, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_compressed_matrix_print_state(&matrix, _devnull);\n tsk_ls_hmm_print_state(&ls_hmm, _devnull);\n\n tsk_ls_hmm_free(&ls_hmm);\n tsk_compressed_matrix_free(&matrix);\n tsk_treeseq_free(ts);\n free(ts);\n }\n\n j = 40;\n ts = caterpillar_tree(j, 5, j - 2);\n ret = tsk_ls_hmm_init(&ls_hmm, ts, rho, mu, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_compressed_matrix_init(&matrix, ts, 1 << 20, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Short circuit this value so we can run the test */\n ls_hmm.max_parsimony_words = 0;\n ret = tsk_ls_hmm_forward(&ls_hmm, h, &matrix, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TOO_MANY_VALUES);\n\n tsk_ls_hmm_free(&ls_hmm);\n tsk_compressed_matrix_free(&matrix);\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nint\nmain(int argc, char **argv)\n{\n CU_TestInfo tests[] = {\n { \"test_single_tree_missing_alleles\", test_single_tree_missing_alleles },\n { \"test_single_tree_exact_match\", test_single_tree_exact_match },\n { \"test_single_tree_missing_haplotype_data\",\n test_single_tree_missing_haplotype_data },\n { \"test_single_tree_match_impossible\", test_single_tree_match_impossible },\n { \"test_single_tree_errors\", test_single_tree_errors },\n { \"test_single_tree_compressed_matrix\", test_single_tree_compressed_matrix },\n { \"test_single_tree_viterbi_matrix\", test_single_tree_viterbi_matrix },\n\n { \"test_multi_tree_exact_match\", test_multi_tree_exact_match },\n { \"test_multi_tree_errors\", test_multi_tree_errors },\n\n { \"test_caterpillar_tree_many_values\", test_caterpillar_tree_many_values },\n { NULL, NULL },\n };\n\n return test_main(tests, argc, argv);\n}\n"
},
{
"path": "c/tests/test_minimal_cpp.cpp",
"content": "/* * MIT License\n *\n * Copyright (c) 2019-2024 Tskit Developers\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n/* Minimal tests to make sure that tskit at least compiles and links\n * in a simple C++ program */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nusing namespace std;\n\nvoid\ntest_kas_strerror()\n{\n std::cout << \"test_kas_strerror\" << endl;\n std::ostringstream o;\n o << kas_strerror(KAS_ERR_NO_MEMORY);\n assert(std::string(\"Out of memory\").compare(o.str()) == 0);\n}\n\nvoid\ntest_strerror()\n{\n std::cout << \"test_strerror\" << endl;\n std::ostringstream o;\n o << tsk_strerror(TSK_ERR_NO_MEMORY);\n assert(std::string(\"Out of memory. (TSK_ERR_NO_MEMORY)\").compare(o.str()) == 0);\n}\n\nvoid\ntest_load_error()\n{\n std::cout << \"test_open_error\" << endl;\n tsk_treeseq_t ts;\n int ret = tsk_treeseq_load(&ts, \"no such file\", 0);\n assert(ret == TSK_ERR_IO);\n tsk_treeseq_free(&ts);\n}\n\nvoid\ntest_table_basics()\n{\n std::cout << \"test_table_basics\" << endl;\n tsk_table_collection_t tables;\n int ret = tsk_table_collection_init(&tables, 0);\n assert(ret == 0);\n\n ret = tsk_node_table_add_row(&tables.nodes, 0, 1.0, TSK_NULL, TSK_NULL, NULL, 0);\n assert(ret == 0);\n ret = tsk_node_table_add_row(&tables.nodes, 0, 2.0, TSK_NULL, TSK_NULL, NULL, 0);\n assert(ret == 1);\n assert(tables.nodes.num_rows == 2);\n\n tsk_table_collection_free(&tables);\n}\n\n/* A definition of sort_edges that uses C++ std::sort and inlining of the\n * comparison function to achieve significantly better performance than\n * the builtin method in tskit.\n */\nint\ncpp_sort_edges(tsk_table_sorter_t *sorter, tsk_size_t start)\n{\n struct _edge {\n double left, right;\n tsk_id_t parent, child;\n\n _edge(double l, double r, tsk_id_t p, tsk_id_t c)\n : left{ l }, right{ r }, parent{ p }, child{ c }\n {\n }\n };\n tsk_edge_table_t *edges = &sorter->tables->edges;\n const double *node_time = sorter->tables->nodes.time;\n std::vector<_edge> sorted_edges;\n size_t num_edges = edges->num_rows;\n size_t j;\n\n /* This is the comparison function. We cannot define an\n * operator < for _edge because we need to bind the node times\n * so we have to use a functional method. This is a copy of the cmp\n * from fwdpp. Only difference is the final time comparison\n * (fwdpp table times go forwards). */\n const auto cmp = [&node_time](const _edge &lhs, const _edge &rhs) {\n auto tl = node_time[lhs.parent];\n auto tr = node_time[rhs.parent];\n if (tl == tr) {\n if (lhs.parent == rhs.parent) {\n if (lhs.child == rhs.child) {\n return lhs.left < rhs.left;\n }\n return lhs.child < rhs.child;\n }\n return lhs.parent < rhs.parent;\n }\n return tl < tr;\n };\n\n assert(start == 0);\n /* Let's not bother with metadata */\n assert(edges->metadata_length == 0);\n\n sorted_edges.reserve(num_edges);\n for (j = 0; j < num_edges; j++) {\n sorted_edges.emplace_back(\n edges->left[j], edges->right[j], edges->parent[j], edges->child[j]);\n }\n\n std::sort(begin(sorted_edges), end(sorted_edges), cmp);\n\n for (j = 0; j < num_edges; j++) {\n edges->left[j] = sorted_edges[j].left;\n edges->right[j] = sorted_edges[j].right;\n edges->parent[j] = sorted_edges[j].parent;\n edges->child[j] = sorted_edges[j].child;\n }\n return 0;\n}\n\nvoid\ntest_edge_sorting()\n{\n std::cout << \"test_edge_sorting\" << endl;\n tsk_table_collection_t tables;\n tsk_id_t n = 10;\n tsk_id_t j;\n int ret = tsk_table_collection_init(&tables, 0);\n assert(ret == 0);\n\n tables.sequence_length = 1.0;\n /* Make a stick tree */\n /* Add nodes and edges */\n for (j = 0; j < n; j++) {\n ret = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, j + 1, TSK_NULL, TSK_NULL, NULL, 0);\n assert(ret == j);\n }\n for (j = n - 1; j > 0; j--) {\n tsk_edge_table_add_row(&tables.edges, 0, 1, j, j - 1, NULL, 0);\n }\n assert(tables.nodes.num_rows == (tsk_size_t) n);\n assert(tables.edges.num_rows == (tsk_size_t) n - 1);\n\n /* Make sure the edges are unsorted */\n /* Not calling TSK_CHECK_TREES so casting is safe */\n ret = (int) tsk_table_collection_check_integrity(&tables, TSK_CHECK_EDGE_ORDERING);\n assert(ret == TSK_ERR_EDGES_NOT_SORTED_PARENT_TIME);\n\n /* Sort the tables */\n tsk_table_sorter_t sorter;\n ret = tsk_table_sorter_init(&sorter, &tables, 0);\n assert(ret == 0);\n /* Set the sort_edges to our local C++ version. We could also set some\n * persistent state in sorter.params if we wanted to. */\n sorter.sort_edges = cpp_sort_edges;\n ret = tsk_table_sorter_run(&sorter, NULL);\n assert(ret == 0);\n tsk_table_sorter_free(&sorter);\n\n /* Make sure the edges are now sorted */\n ret = (int) tsk_table_collection_check_integrity(&tables, TSK_CHECK_EDGE_ORDERING);\n assert(ret == 0);\n\n tsk_table_collection_free(&tables);\n}\n\nint\nsort_edges_raises_exception(tsk_table_sorter_t *sorter, tsk_size_t start)\n{\n throw std::exception();\n return 0;\n}\n\nint\nsort_edges_raises_non_exception(tsk_table_sorter_t *sorter, tsk_size_t start)\n{\n throw 42;\n return 0;\n}\n\nint\nsafe_sort_edges(tsk_table_sorter_t *sorter, tsk_size_t start)\n{\n int ret = 0;\n if (sorter->user_data == NULL) {\n try {\n ret = sort_edges_raises_exception(sorter, start);\n } catch (...) {\n ret = -12345;\n }\n } else {\n try {\n ret = sort_edges_raises_non_exception(sorter, start);\n } catch (...) {\n ret = -12346;\n }\n }\n return ret;\n}\n\nvoid\ntest_edge_sorting_errors()\n{\n /* Some inexplicable error happened here on 32 bit Windows where the\n * exceptions were not being caught as expected. This seems much\n * more likely to be a platform quirk that a real bug in our code,\n * so just disabling the test there.\n *\n * https://github.com/tskit-dev/tskit/issues/1790\n * https://github.com/tskit-dev/tskit/pull/1791\n */\n#if !defined(_WIN32)\n std::cout << \"test_edge_sorting_errors\" << endl;\n tsk_table_collection_t tables;\n tsk_table_sorter_t sorter;\n tsk_id_t ret = tsk_table_collection_init(&tables, 0);\n\n assert(ret == 0);\n tables.sequence_length = 1.0;\n\n ret = tsk_table_sorter_init(&sorter, &tables, 0);\n assert(ret == 0);\n sorter.sort_edges = safe_sort_edges;\n ret = tsk_table_sorter_run(&sorter, NULL);\n assert(ret == -12345);\n\n /* Use the user_data as a way to communicate with the sorter\n * function. Here, we want to try out two different types\n * of exception that get thrown. */\n sorter.user_data = &tables;\n ret = tsk_table_sorter_run(&sorter, NULL);\n assert(ret == -12346);\n\n tsk_table_sorter_free(&sorter);\n tsk_table_collection_free(&tables);\n#endif\n}\n\nint\nmain()\n{\n test_kas_strerror();\n test_strerror();\n test_load_error();\n test_table_basics();\n test_edge_sorting();\n test_edge_sorting_errors();\n return 0;\n}\n"
},
{
"path": "c/tests/test_stats.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2024 Tskit Developers\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \"testlib.h\"\n#include \n#include \n\n#include \n#include \n#include \n\nstatic bool\nmulti_mutations_exist(tsk_treeseq_t *ts, tsk_id_t start, tsk_id_t end)\n{\n int ret;\n tsk_id_t j;\n tsk_site_t site;\n\n for (j = start; j < TSK_MIN((tsk_id_t) tsk_treeseq_get_num_sites(ts), end); j++) {\n ret = tsk_treeseq_get_site(ts, j, &site);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n if (site.mutations_length > 1) {\n return true;\n }\n }\n return false;\n}\n\nstatic void\nverify_ld(tsk_treeseq_t *ts)\n{\n int ret;\n tsk_size_t num_sites = tsk_treeseq_get_num_sites(ts);\n tsk_site_t *sites = tsk_malloc(num_sites * sizeof(tsk_site_t));\n int *num_site_mutations = tsk_malloc(num_sites * sizeof(int));\n tsk_ld_calc_t ld_calc;\n double *r2, *r2_prime, x;\n tsk_id_t j;\n tsk_size_t num_r2_values;\n double eps = 1e-6;\n\n r2 = tsk_calloc(num_sites, sizeof(double));\n r2_prime = tsk_calloc(num_sites, sizeof(double));\n CU_ASSERT_FATAL(r2 != NULL);\n CU_ASSERT_FATAL(r2_prime != NULL);\n CU_ASSERT_FATAL(sites != NULL);\n CU_ASSERT_FATAL(num_site_mutations != NULL);\n\n ret = tsk_ld_calc_init(&ld_calc, ts);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_ld_calc_print_state(&ld_calc, _devnull);\n\n for (j = 0; j < (tsk_id_t) num_sites; j++) {\n ret = tsk_treeseq_get_site(ts, j, sites + j);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n num_site_mutations[j] = (int) sites[j].mutations_length;\n ret = tsk_ld_calc_get_r2(&ld_calc, j, j, &x);\n if (num_site_mutations[j] <= 1) {\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(x, 1.0, eps);\n } else {\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_ONLY_INFINITE_SITES);\n }\n }\n\n if (num_sites > 0) {\n /* Some checks in the forward direction */\n ret = tsk_ld_calc_get_r2_array(\n &ld_calc, 0, TSK_DIR_FORWARD, num_sites, DBL_MAX, r2, &num_r2_values);\n if (multi_mutations_exist(ts, 0, (tsk_id_t) num_sites)) {\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_ONLY_INFINITE_SITES);\n } else {\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(num_r2_values, num_sites - 1);\n }\n tsk_ld_calc_print_state(&ld_calc, _devnull);\n\n ret = tsk_ld_calc_get_r2_array(&ld_calc, (tsk_id_t) num_sites - 2,\n TSK_DIR_FORWARD, num_sites, DBL_MAX, r2_prime, &num_r2_values);\n if (multi_mutations_exist(ts, (tsk_id_t) num_sites - 2, (tsk_id_t) num_sites)) {\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_ONLY_INFINITE_SITES);\n } else {\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(num_r2_values, 1);\n }\n tsk_ld_calc_print_state(&ld_calc, _devnull);\n\n ret = tsk_ld_calc_get_r2_array(\n &ld_calc, 0, TSK_DIR_FORWARD, num_sites, DBL_MAX, r2_prime, &num_r2_values);\n if (multi_mutations_exist(ts, 0, (tsk_id_t) num_sites)) {\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_ONLY_INFINITE_SITES);\n } else {\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(num_r2_values, num_sites - 1);\n for (j = 0; j < (tsk_id_t) num_r2_values; j++) {\n CU_ASSERT_EQUAL_FATAL(r2[j], r2_prime[j]);\n ret = tsk_ld_calc_get_r2(&ld_calc, 0, j + 1, &x);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(r2[j], x, eps);\n }\n }\n\n /* Some checks in the reverse direction */\n ret = tsk_ld_calc_get_r2_array(&ld_calc, (tsk_id_t) num_sites - 1,\n TSK_DIR_REVERSE, num_sites, DBL_MAX, r2, &num_r2_values);\n if (multi_mutations_exist(ts, 0, (tsk_id_t) num_sites)) {\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_ONLY_INFINITE_SITES);\n } else {\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(num_r2_values, num_sites - 1);\n }\n tsk_ld_calc_print_state(&ld_calc, _devnull);\n\n ret = tsk_ld_calc_get_r2_array(\n &ld_calc, 1, TSK_DIR_REVERSE, num_sites, DBL_MAX, r2_prime, &num_r2_values);\n if (multi_mutations_exist(ts, 0, 2)) {\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_ONLY_INFINITE_SITES);\n } else {\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(num_r2_values, 1);\n }\n\n ret = tsk_ld_calc_get_r2_array(&ld_calc, (tsk_id_t) num_sites - 1,\n TSK_DIR_REVERSE, num_sites, DBL_MAX, r2_prime, &num_r2_values);\n if (multi_mutations_exist(ts, 0, (tsk_id_t) num_sites)) {\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_ONLY_INFINITE_SITES);\n } else {\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(num_r2_values, num_sites - 1);\n tsk_ld_calc_print_state(&ld_calc, _devnull);\n\n for (j = 0; j < (tsk_id_t) num_r2_values; j++) {\n CU_ASSERT_EQUAL_FATAL(r2[j], r2_prime[j]);\n ret = tsk_ld_calc_get_r2(&ld_calc, (tsk_id_t) num_sites - 1,\n (tsk_id_t) num_sites - j - 2, &x);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(r2[j], x, eps);\n }\n }\n\n /* Check some error conditions */\n ret = tsk_ld_calc_get_r2_array(\n &ld_calc, 0, 0, num_sites, DBL_MAX, r2, &num_r2_values);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n }\n\n /* Check some error conditions */\n for (j = (tsk_id_t) num_sites; j < (tsk_id_t) num_sites + 2; j++) {\n ret = tsk_ld_calc_get_r2_array(\n &ld_calc, j, TSK_DIR_FORWARD, num_sites, DBL_MAX, r2, &num_r2_values);\n CU_ASSERT_EQUAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n ret = tsk_ld_calc_get_r2(&ld_calc, j, 0, r2);\n CU_ASSERT_EQUAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n ret = tsk_ld_calc_get_r2(&ld_calc, 0, j, r2);\n CU_ASSERT_EQUAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n }\n\n tsk_ld_calc_free(&ld_calc);\n free(r2);\n free(r2_prime);\n free(sites);\n free(num_site_mutations);\n}\n\n/* FIXME: this test is weak and should check the return value somehow.\n * We should also have simplest and single tree tests along with separate\n * tests for the error conditions. This should be done as part of the general\n * stats framework.\n */\nstatic void\nverify_genealogical_nearest_neighbours(tsk_treeseq_t *ts)\n{\n int ret;\n const tsk_id_t *samples;\n const tsk_id_t *sample_sets[2];\n tsk_size_t sample_set_size[2];\n tsk_size_t num_samples = tsk_treeseq_get_num_samples(ts);\n double *A = tsk_malloc(2 * num_samples * sizeof(double));\n CU_ASSERT_FATAL(A != NULL);\n\n samples = tsk_treeseq_get_samples(ts);\n\n sample_sets[0] = samples;\n sample_set_size[0] = num_samples / 2;\n sample_sets[1] = samples + sample_set_size[0];\n sample_set_size[1] = num_samples - sample_set_size[0];\n\n ret = tsk_treeseq_genealogical_nearest_neighbours(\n ts, samples, num_samples, sample_sets, sample_set_size, 2, 0, A);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n sample_sets[0] = samples;\n sample_set_size[0] = 1;\n sample_sets[1] = samples + 1;\n sample_set_size[1] = 1;\n\n ret = tsk_treeseq_genealogical_nearest_neighbours(\n ts, samples, num_samples, sample_sets, sample_set_size, 2, 0, A);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n free(A);\n}\n\n/* FIXME: this test is weak and should check the return value somehow.\n * We should also have simplest and single tree tests along with separate\n * tests for the error conditions. This should be done as part of the general\n * stats framework.\n */\nstatic void\nverify_mean_descendants(tsk_treeseq_t *ts)\n{\n int ret;\n tsk_id_t *samples;\n const tsk_id_t *sample_sets[2];\n tsk_size_t sample_set_size[2];\n tsk_size_t num_samples = tsk_treeseq_get_num_samples(ts);\n double *C = tsk_malloc(2 * tsk_treeseq_get_num_nodes(ts) * sizeof(double));\n CU_ASSERT_FATAL(C != NULL);\n\n samples = tsk_malloc(num_samples * sizeof(*samples));\n tsk_memcpy(samples, tsk_treeseq_get_samples(ts), num_samples * sizeof(*samples));\n\n sample_sets[0] = samples;\n sample_set_size[0] = num_samples / 2;\n sample_sets[1] = samples + sample_set_size[0];\n sample_set_size[1] = num_samples - sample_set_size[0];\n\n ret = tsk_treeseq_mean_descendants(ts, sample_sets, sample_set_size, 2, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Check some error conditions */\n ret = tsk_treeseq_mean_descendants(ts, sample_sets, sample_set_size, 0, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n samples[0] = -1;\n ret = tsk_treeseq_mean_descendants(ts, sample_sets, sample_set_size, 2, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n samples[0] = (tsk_id_t) tsk_treeseq_get_num_nodes(ts) + 1;\n ret = tsk_treeseq_mean_descendants(ts, sample_sets, sample_set_size, 2, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n free(samples);\n free(C);\n}\n\n/* Check the divergence matrix by running against the stats API equivalent\n * code.\n */\nstatic void\nverify_divergence_matrix(tsk_treeseq_t *ts, tsk_flags_t options)\n{\n int ret;\n const tsk_size_t n = tsk_treeseq_get_num_samples(ts);\n const tsk_id_t *samples = tsk_treeseq_get_samples(ts);\n tsk_size_t sample_set_sizes[n];\n tsk_id_t index_tuples[2 * n * n];\n double D1[n * n], D2[n * n];\n tsk_size_t i, j, k;\n\n for (j = 0; j < n; j++) {\n sample_set_sizes[j] = 1;\n for (k = 0; k < n; k++) {\n index_tuples[2 * (j * n + k)] = (tsk_id_t) j;\n index_tuples[2 * (j * n + k) + 1] = (tsk_id_t) k;\n }\n }\n ret = tsk_treeseq_divergence(\n ts, n, sample_set_sizes, samples, n * n, index_tuples, 0, NULL, options, D1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_divergence_matrix(\n ts, n, sample_set_sizes, samples, 0, NULL, options, D2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = 0; j < n; j++) {\n for (k = 0; k < n; k++) {\n i = j * n + k;\n /* printf(\"%d\\t%d\\t%f\\t%f\\n\", (int) j, (int) k, D1[i], D2[i]); */\n if (j == k) {\n CU_ASSERT_EQUAL(D2[i], 0);\n } else {\n CU_ASSERT_DOUBLE_EQUAL(D1[i], D2[i], 1E-6);\n }\n }\n }\n}\n\n/* Check coalescence counts */\nstatic void\nverify_pair_coalescence_counts(tsk_treeseq_t *ts, tsk_flags_t options)\n{\n int ret;\n const tsk_size_t n = tsk_treeseq_get_num_samples(ts);\n const tsk_size_t N = tsk_treeseq_get_num_nodes(ts);\n const tsk_size_t T = tsk_treeseq_get_num_trees(ts);\n const tsk_id_t *samples = tsk_treeseq_get_samples(ts);\n const double *breakpoints = tsk_treeseq_get_breakpoints(ts);\n const tsk_size_t P = 2;\n const tsk_size_t I = P * (P + 1) / 2;\n const tsk_size_t B = 8;\n tsk_id_t sample_sets[n];\n tsk_size_t sample_set_sizes[P];\n tsk_id_t index_tuples[2 * I];\n tsk_id_t node_bin_map[N];\n tsk_size_t dim = T * N * I;\n double C[dim];\n double C_B[T * B * I];\n double C_Nh[T * (N / 2) * I];\n tsk_size_t i, j, k;\n\n for (i = 0; i < n; i++) {\n sample_sets[i] = samples[i];\n }\n\n for (i = 0; i < P; i++) {\n sample_set_sizes[i] = 0;\n }\n for (j = 0; j < n; j++) {\n i = j / ((n + P - 1) / P);\n sample_set_sizes[i]++;\n }\n\n for (j = 0, i = 0; j < P; j++) {\n for (k = j; k < P; k++) {\n index_tuples[i++] = (tsk_id_t) j;\n index_tuples[i++] = (tsk_id_t) k;\n }\n }\n\n /* test various bin assignments */\n for (i = 0; i < N; i++) {\n node_bin_map[i] = ((tsk_id_t) (i % B));\n }\n ret = tsk_treeseq_pair_coalescence_counts(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, options, C_B);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (i = 0; i < N; i++) {\n node_bin_map[i] = i < N / 2 ? ((tsk_id_t) i) : TSK_NULL;\n }\n ret = tsk_treeseq_pair_coalescence_counts(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, N / 2, node_bin_map, options, C_Nh);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (i = 0; i < N; i++) {\n node_bin_map[i] = (tsk_id_t) i;\n }\n ret = tsk_treeseq_pair_coalescence_counts(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, N, node_bin_map, options, C);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* cover errors */\n double bad_breakpoints[2] = { breakpoints[1], 0.0 };\n ret = tsk_treeseq_pair_coalescence_counts(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, 1, bad_breakpoints, N, node_bin_map, options, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n index_tuples[0] = (tsk_id_t) P;\n ret = tsk_treeseq_pair_coalescence_counts(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, N, node_bin_map, options, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SAMPLE_SET_INDEX);\n index_tuples[0] = 0;\n\n tsk_size_t tmp = sample_set_sizes[0];\n sample_set_sizes[0] = 0;\n ret = tsk_treeseq_pair_coalescence_counts(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, N, node_bin_map, options, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EMPTY_SAMPLE_SET);\n sample_set_sizes[0] = tmp;\n\n sample_sets[1] = 0;\n ret = tsk_treeseq_pair_coalescence_counts(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, N, node_bin_map, options, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n sample_sets[1] = 1;\n\n ret = tsk_treeseq_pair_coalescence_counts(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, N - 1, node_bin_map, options, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_NODE_BIN_MAP_DIM);\n\n ret = tsk_treeseq_pair_coalescence_counts(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, 0, node_bin_map, options, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_NODE_BIN_MAP_DIM);\n\n node_bin_map[0] = -2;\n ret = tsk_treeseq_pair_coalescence_counts(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, N, node_bin_map, options, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_NODE_BIN_MAP);\n node_bin_map[0] = 0;\n}\n\n/* Check coalescence quantiles */\nstatic void\nverify_pair_coalescence_quantiles(tsk_treeseq_t *ts)\n{\n int ret;\n const tsk_size_t n = tsk_treeseq_get_num_samples(ts);\n const tsk_size_t N = tsk_treeseq_get_num_nodes(ts);\n const tsk_size_t T = tsk_treeseq_get_num_trees(ts);\n const tsk_id_t *samples = tsk_treeseq_get_samples(ts);\n const double *breakpoints = tsk_treeseq_get_breakpoints(ts);\n const double *nodes_time = ts->tables->nodes.time;\n const double max_time = ts->max_time;\n const tsk_size_t P = 2;\n const tsk_size_t Q = 5;\n const tsk_size_t B = 4;\n const tsk_size_t I = P * (P + 1) / 2;\n double quantiles[] = { 0.0, 0.25, 0.5, 0.75, 1.0 };\n double epochs[] = { 0.0, max_time / 4, max_time / 2, max_time, INFINITY };\n tsk_id_t sample_sets[n];\n tsk_size_t sample_set_sizes[P];\n tsk_id_t index_tuples[2 * I];\n tsk_id_t node_bin_map[N];\n tsk_id_t node_bin_map_empty[N];\n tsk_id_t node_bin_map_shuff[N];\n tsk_size_t dim = T * Q * I;\n double C[dim];\n tsk_size_t i, j, k;\n\n for (i = 0; i < N; i++) {\n node_bin_map_empty[i] = TSK_NULL;\n node_bin_map_shuff[i] = (tsk_id_t) (i % B);\n for (j = 0; j < B; j++) {\n if (nodes_time[i] >= epochs[j] && nodes_time[i] < epochs[j + 1]) {\n node_bin_map[i] = (tsk_id_t) j;\n }\n }\n }\n\n for (i = 0; i < n; i++) {\n sample_sets[i] = samples[i];\n }\n\n for (i = 0; i < P; i++) {\n sample_set_sizes[i] = 0;\n }\n for (j = 0; j < n; j++) {\n i = j / (n / P);\n sample_set_sizes[i]++;\n }\n\n for (j = 0, i = 0; j < P; j++) {\n for (k = j; k < P; k++) {\n index_tuples[i++] = (tsk_id_t) j;\n index_tuples[i++] = (tsk_id_t) k;\n }\n }\n\n ret = tsk_treeseq_pair_coalescence_quantiles(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, Q, quantiles, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n quantiles[Q - 1] = 0.9;\n ret = tsk_treeseq_pair_coalescence_quantiles(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, Q, quantiles, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n quantiles[Q - 1] = 1.0;\n\n ret = tsk_treeseq_pair_coalescence_quantiles(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map_empty, Q, quantiles, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* cover errors */\n quantiles[0] = -1.0;\n ret = tsk_treeseq_pair_coalescence_quantiles(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, Q, quantiles, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_QUANTILES);\n quantiles[0] = 0.0;\n\n quantiles[Q - 1] = 2.0;\n ret = tsk_treeseq_pair_coalescence_quantiles(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, Q, quantiles, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_QUANTILES);\n quantiles[Q - 1] = 1.0;\n\n quantiles[1] = 0.0;\n quantiles[0] = 0.25;\n ret = tsk_treeseq_pair_coalescence_quantiles(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, Q, quantiles, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_QUANTILES);\n quantiles[0] = 0.0;\n quantiles[1] = 0.25;\n\n ts->tables->nodes.time[N - 1] = -1.0;\n ret = tsk_treeseq_pair_coalescence_quantiles(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map_shuff, Q, quantiles, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSORTED_TIMES);\n ts->tables->nodes.time[N - 1] = max_time;\n\n node_bin_map[0] = (tsk_id_t) B;\n ret = tsk_treeseq_pair_coalescence_quantiles(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, Q, quantiles, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_NODE_BIN_MAP_DIM);\n node_bin_map[0] = 0;\n}\n\n/* Check coalescence rates */\nstatic void\nverify_pair_coalescence_rates(tsk_treeseq_t *ts)\n{\n int ret;\n const tsk_size_t n = tsk_treeseq_get_num_samples(ts);\n const tsk_size_t N = tsk_treeseq_get_num_nodes(ts);\n const tsk_size_t T = tsk_treeseq_get_num_trees(ts);\n const tsk_id_t *samples = tsk_treeseq_get_samples(ts);\n const double *breakpoints = tsk_treeseq_get_breakpoints(ts);\n const double *nodes_time = ts->tables->nodes.time;\n const double max_time = ts->max_time;\n const tsk_size_t P = 2;\n const tsk_size_t B = 5;\n const tsk_size_t I = P * (P + 1) / 2;\n double epochs[]\n = { 0.0, max_time / 4, max_time / 2, max_time, max_time * 2, INFINITY };\n tsk_id_t sample_sets[n];\n tsk_size_t sample_set_sizes[P];\n tsk_id_t index_tuples[2 * I];\n tsk_id_t node_bin_map[N];\n tsk_id_t empty_node_bin_map[N];\n tsk_size_t dim = T * B * I;\n double C[dim];\n tsk_size_t i, j, k;\n\n for (i = 0; i < N; i++) {\n node_bin_map[i] = TSK_NULL;\n for (j = 0; j < B; j++) {\n if (nodes_time[i] >= epochs[j] && nodes_time[i] < epochs[j + 1]) {\n node_bin_map[i] = (tsk_id_t) j;\n }\n }\n empty_node_bin_map[i] = TSK_NULL;\n }\n\n for (i = 0; i < n; i++) {\n sample_sets[i] = samples[i];\n }\n\n for (i = 0; i < P; i++) {\n sample_set_sizes[i] = 0;\n }\n for (j = 0; j < n; j++) {\n i = j / (n / P);\n sample_set_sizes[i]++;\n }\n\n for (j = 0, i = 0; j < P; j++) {\n for (k = j; k < P; k++) {\n index_tuples[i++] = (tsk_id_t) j;\n index_tuples[i++] = (tsk_id_t) k;\n }\n }\n\n ret = tsk_treeseq_pair_coalescence_rates(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, epochs, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n node_bin_map[0] = TSK_NULL;\n ret = tsk_treeseq_pair_coalescence_rates(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, epochs, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n node_bin_map[0] = 0;\n\n ret = tsk_treeseq_pair_coalescence_rates(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, empty_node_bin_map, epochs, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* cover errors */\n ret = tsk_treeseq_pair_coalescence_rates(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, 0, node_bin_map, epochs, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_TIME_WINDOWS_DIM);\n\n epochs[0] = epochs[1] / 2;\n ret = tsk_treeseq_pair_coalescence_rates(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, epochs, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SAMPLE_PAIR_TIMES);\n epochs[0] = 0.0;\n\n epochs[2] = epochs[1];\n ret = tsk_treeseq_pair_coalescence_rates(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, epochs, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_TIME_WINDOWS);\n epochs[2] = max_time / 2;\n\n epochs[B] = DBL_MAX;\n ret = tsk_treeseq_pair_coalescence_rates(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, epochs, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_TIME_WINDOWS_END);\n epochs[B] = INFINITY;\n\n node_bin_map[0] = (tsk_id_t) B;\n ret = tsk_treeseq_pair_coalescence_rates(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, epochs, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_NODE_BIN_MAP_DIM);\n node_bin_map[0] = 0;\n\n node_bin_map[0] = (tsk_id_t) (B - 1);\n ret = tsk_treeseq_pair_coalescence_rates(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, epochs, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_NODE_TIME_WINDOW);\n node_bin_map[0] = 0;\n\n node_bin_map[N - 1] = 0;\n ret = tsk_treeseq_pair_coalescence_rates(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, epochs, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_NODE_TIME_WINDOW);\n node_bin_map[N - 1] = 3;\n\n tsk_size_t tmp = sample_set_sizes[0];\n sample_set_sizes[0] = 0;\n ret = tsk_treeseq_pair_coalescence_rates(ts, P, sample_set_sizes, sample_sets, I,\n index_tuples, T, breakpoints, B, node_bin_map, epochs, 0, C);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EMPTY_SAMPLE_SET);\n sample_set_sizes[0] = tmp;\n}\n\ntypedef struct {\n int call_count;\n int error_on;\n int error_code;\n} general_stat_error_params_t;\n\nstatic int\ngeneral_stat_error(tsk_size_t TSK_UNUSED(K), const double *TSK_UNUSED(X), tsk_size_t M,\n double *Y, void *params)\n{\n int ret = 0;\n CU_ASSERT_FATAL(M == 1);\n Y[0] = 0;\n general_stat_error_params_t *the_params = (general_stat_error_params_t *) params;\n if (the_params->call_count == the_params->error_on) {\n ret = the_params->error_code;\n }\n the_params->call_count++;\n return ret;\n}\n\nstatic void\nverify_window_errors(tsk_treeseq_t *ts, tsk_flags_t mode)\n{\n int ret;\n tsk_size_t num_samples = tsk_treeseq_get_num_samples(ts);\n double *W = tsk_calloc(num_samples, sizeof(double));\n /* node mode requires this much space at least */\n double *sigma = tsk_calloc(tsk_treeseq_get_num_nodes(ts), sizeof(double));\n double windows[] = { 0, 0, 0 };\n tsk_flags_t options = mode;\n\n /* Window errors */\n ret = tsk_treeseq_general_stat(\n ts, 1, W, 1, general_stat_error, NULL, 0, windows, options, sigma);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_NUM_WINDOWS);\n\n ret = tsk_treeseq_general_stat(\n ts, 1, W, 1, general_stat_error, NULL, 2, windows, options, sigma);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n windows[0] = -1;\n ret = tsk_treeseq_general_stat(\n ts, 1, W, 1, general_stat_error, NULL, 2, windows, options, sigma);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n windows[1] = -1;\n ret = tsk_treeseq_general_stat(\n ts, 1, W, 1, general_stat_error, NULL, 1, windows, options, sigma);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n windows[0] = 10;\n ret = tsk_treeseq_general_stat(\n ts, 1, W, 1, general_stat_error, NULL, 2, windows, options, sigma);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n windows[0] = 0;\n windows[2] = tsk_treeseq_get_sequence_length(ts) + 1;\n ret = tsk_treeseq_general_stat(\n ts, 1, W, 1, general_stat_error, NULL, 2, windows, options, sigma);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n windows[0] = 0;\n windows[1] = -1;\n windows[2] = tsk_treeseq_get_sequence_length(ts);\n ret = tsk_treeseq_general_stat(\n ts, 1, W, 1, general_stat_error, NULL, 2, windows, options, sigma);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n free(W);\n free(sigma);\n}\n\nstatic void\nverify_summary_func_errors(tsk_treeseq_t *ts, tsk_flags_t mode)\n{\n int ret;\n tsk_size_t num_samples = tsk_treeseq_get_num_samples(ts);\n double *W = tsk_calloc(num_samples, sizeof(double));\n /* We need this much space for NODE mode */\n double *sigma = tsk_calloc(tsk_treeseq_get_num_nodes(ts), sizeof(double));\n int j;\n general_stat_error_params_t params;\n CU_ASSERT_FATAL(W != NULL);\n\n /* Errors in the summary function */\n j = 1;\n while (true) {\n params.call_count = 0;\n params.error_on = j;\n params.error_code = -j;\n ret = tsk_treeseq_general_stat(ts, 1, W, 1, general_stat_error, ¶ms, 0, NULL,\n TSK_STAT_POLARISED | mode, sigma);\n if (ret == 0) {\n break;\n }\n CU_ASSERT_EQUAL_FATAL(ret, params.error_code);\n j++;\n }\n CU_ASSERT_FATAL(j > 1);\n\n j = 1;\n while (true) {\n params.call_count = 0;\n params.error_on = j;\n params.error_code = -j;\n ret = tsk_treeseq_general_stat(\n ts, 1, W, 1, general_stat_error, ¶ms, 0, NULL, mode, sigma);\n if (ret == 0) {\n break;\n }\n CU_ASSERT_EQUAL_FATAL(ret, params.error_code);\n j++;\n }\n CU_ASSERT_FATAL(j > 1);\n\n free(W);\n free(sigma);\n}\n\nstatic void\nverify_branch_general_stat_errors(tsk_treeseq_t *ts)\n{\n verify_summary_func_errors(ts, TSK_STAT_BRANCH);\n verify_window_errors(ts, TSK_STAT_BRANCH);\n}\n\nstatic void\nverify_site_general_stat_errors(tsk_treeseq_t *ts)\n{\n verify_window_errors(ts, TSK_STAT_SITE);\n verify_summary_func_errors(ts, TSK_STAT_SITE);\n}\n\nstatic void\nverify_node_general_stat_errors(tsk_treeseq_t *ts)\n{\n verify_window_errors(ts, TSK_STAT_NODE);\n verify_summary_func_errors(ts, TSK_STAT_NODE);\n}\n\nstatic void\nverify_one_way_weighted_func_errors(tsk_treeseq_t *ts, one_way_weighted_method *method)\n{\n int ret;\n tsk_size_t num_samples = tsk_treeseq_get_num_samples(ts);\n double *weights = tsk_malloc(num_samples * sizeof(double));\n double bad_windows[] = { 0, -1 };\n double result;\n tsk_size_t j;\n\n for (j = 0; j < num_samples; j++) {\n weights[j] = 1.0;\n }\n\n ret = method(ts, 0, weights, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INSUFFICIENT_WEIGHTS);\n\n ret = method(ts, 1, weights, 1, bad_windows, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n free(weights);\n}\n\nstatic void\nverify_one_way_weighted_covariate_func_errors(\n tsk_treeseq_t *ts, one_way_covariates_method *method)\n{\n int ret;\n tsk_size_t num_samples = tsk_treeseq_get_num_samples(ts);\n double *weights = tsk_malloc(num_samples * sizeof(double));\n double *covariates = NULL;\n double bad_windows[] = { 0, -1 };\n double result;\n tsk_size_t j;\n\n for (j = 0; j < num_samples; j++) {\n weights[j] = 1.0;\n }\n\n ret = method(ts, 0, weights, 0, covariates, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INSUFFICIENT_WEIGHTS);\n\n ret = method(ts, 1, weights, 0, covariates, 1, bad_windows, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n free(weights);\n}\n\nstatic void\nverify_one_way_stat_func_errors(tsk_treeseq_t *ts, one_way_sample_stat_method *method)\n{\n int ret;\n tsk_id_t num_nodes = (tsk_id_t) tsk_treeseq_get_num_nodes(ts);\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes = 4;\n double windows[] = { 0, 0, 0 };\n double result;\n\n ret = method(ts, 0, &sample_set_sizes, samples, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INSUFFICIENT_SAMPLE_SETS);\n\n samples[0] = TSK_NULL;\n ret = method(ts, 1, &sample_set_sizes, samples, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n samples[0] = -10;\n ret = method(ts, 1, &sample_set_sizes, samples, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n samples[0] = num_nodes;\n ret = method(ts, 1, &sample_set_sizes, samples, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n samples[0] = num_nodes + 1;\n ret = method(ts, 1, &sample_set_sizes, samples, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n samples[0] = num_nodes - 1;\n ret = method(ts, 1, &sample_set_sizes, samples, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SAMPLES);\n\n samples[0] = 1;\n ret = method(ts, 1, &sample_set_sizes, samples, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n\n samples[0] = 0;\n sample_set_sizes = 0;\n ret = method(ts, 1, &sample_set_sizes, samples, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EMPTY_SAMPLE_SET);\n\n sample_set_sizes = 4;\n /* Window errors */\n ret = method(ts, 1, &sample_set_sizes, samples, 0, windows, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_NUM_WINDOWS);\n\n ret = method(ts, 1, &sample_set_sizes, samples, 2, windows, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n}\n\n// Temporary definition for time_windows in tsk_treeseq_allele_frequency_spectrum\ntypedef int one_way_sample_stat_method_tw(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_windows, const double *windows,\n tsk_size_t num_time_windows, const double *time_windows, tsk_flags_t options,\n double *result);\n\n// Temporary duplicate for time-windows-having methods\nstatic void\nverify_one_way_stat_func_errors_tw(\n tsk_treeseq_t *ts, one_way_sample_stat_method_tw *method)\n{\n int ret;\n tsk_id_t num_nodes = (tsk_id_t) tsk_treeseq_get_num_nodes(ts);\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes = 4;\n double windows[] = { 0, 0, 0 };\n double time_windows[] = { -1, 0.5, INFINITY };\n double result;\n\n ret = method(ts, 0, &sample_set_sizes, samples, 0, NULL, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INSUFFICIENT_SAMPLE_SETS);\n\n samples[0] = TSK_NULL;\n ret = method(ts, 1, &sample_set_sizes, samples, 0, NULL, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n samples[0] = -10;\n ret = method(ts, 1, &sample_set_sizes, samples, 0, NULL, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n samples[0] = num_nodes;\n ret = method(ts, 1, &sample_set_sizes, samples, 0, NULL, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n samples[0] = num_nodes + 1;\n ret = method(ts, 1, &sample_set_sizes, samples, 0, NULL, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n samples[0] = num_nodes - 1;\n ret = method(ts, 1, &sample_set_sizes, samples, 0, NULL, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SAMPLES);\n\n samples[0] = 1;\n ret = method(ts, 1, &sample_set_sizes, samples, 0, NULL, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n\n samples[0] = 0;\n sample_set_sizes = 0;\n ret = method(ts, 1, &sample_set_sizes, samples, 0, NULL, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EMPTY_SAMPLE_SET);\n\n sample_set_sizes = 4;\n /* Window errors */\n ret = method(ts, 1, &sample_set_sizes, samples, 0, windows, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_NUM_WINDOWS);\n\n ret = method(ts, 1, &sample_set_sizes, samples, 2, windows, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n /* Time window errors */\n ret = method(\n ts, 1, &sample_set_sizes, samples, 0, NULL, 0, time_windows, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_TIME_WINDOWS_DIM);\n\n ret = method(\n ts, 1, &sample_set_sizes, samples, 0, NULL, 2, time_windows, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_TIME_WINDOWS);\n\n time_windows[0] = 0.1;\n ret = method(\n ts, 1, &sample_set_sizes, samples, 0, NULL, 2, time_windows, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_TIME_WINDOWS);\n\n time_windows[0] = 0;\n time_windows[1] = 0;\n ret = method(\n ts, 1, &sample_set_sizes, samples, 0, NULL, 2, time_windows, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_TIME_WINDOWS);\n}\n\nstatic void\nverify_two_way_stat_func_errors(\n tsk_treeseq_t *ts, general_sample_stat_method *method, tsk_flags_t options)\n{\n int ret;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes[] = { 2, 2 };\n tsk_id_t set_indexes[] = { 0, 1 };\n double result;\n\n ret = method(ts, 0, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n options | TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INSUFFICIENT_SAMPLE_SETS);\n\n ret = method(ts, 2, sample_set_sizes, samples, 0, set_indexes, 0, NULL,\n options | TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INSUFFICIENT_INDEX_TUPLES);\n\n set_indexes[0] = -1;\n ret = method(ts, 2, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n options | TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SAMPLE_SET_INDEX);\n set_indexes[0] = 0;\n set_indexes[1] = 2;\n ret = method(ts, 2, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n options | TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SAMPLE_SET_INDEX);\n}\n\nstatic void\nverify_two_way_weighted_stat_func_errors(\n tsk_treeseq_t *ts, two_way_weighted_method *method, tsk_flags_t options)\n{\n int ret;\n tsk_id_t indexes[] = { 0, 0, 0, 1 };\n double bad_windows[] = { -1, -1 };\n double weights[10];\n double result[10];\n\n memset(weights, 0, sizeof(weights));\n\n ret = method(ts, 2, weights, 2, indexes, 0, NULL, result, options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = method(ts, 2, weights, 2, indexes, 0, NULL, result,\n options | TSK_STAT_SITE | TSK_STAT_NODE);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MULTIPLE_STAT_MODES);\n\n ret = method(ts, 0, weights, 2, indexes, 0, NULL, result, options);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INSUFFICIENT_WEIGHTS);\n\n ret = method(ts, 2, weights, 2, indexes, 1, bad_windows, result, options);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n}\n\nstatic void\nverify_three_way_stat_func_errors(tsk_treeseq_t *ts, general_sample_stat_method *method)\n{\n int ret;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes[] = { 1, 1, 2 };\n tsk_id_t set_indexes[] = { 0, 1, 2 };\n double result;\n\n ret = method(ts, 0, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INSUFFICIENT_SAMPLE_SETS);\n\n ret = method(ts, 3, sample_set_sizes, samples, 0, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INSUFFICIENT_INDEX_TUPLES);\n\n set_indexes[0] = -1;\n ret = method(ts, 3, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SAMPLE_SET_INDEX);\n set_indexes[0] = 0;\n set_indexes[1] = 3;\n ret = method(ts, 3, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SAMPLE_SET_INDEX);\n}\n\nstatic void\nverify_four_way_stat_func_errors(tsk_treeseq_t *ts, general_sample_stat_method *method)\n{\n int ret;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes[] = { 1, 1, 1, 1 };\n tsk_id_t set_indexes[] = { 0, 1, 2, 3 };\n double result;\n\n ret = method(ts, 0, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INSUFFICIENT_SAMPLE_SETS);\n\n ret = method(ts, 4, sample_set_sizes, samples, 0, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INSUFFICIENT_INDEX_TUPLES);\n\n set_indexes[0] = -1;\n ret = method(ts, 4, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SAMPLE_SET_INDEX);\n set_indexes[0] = 0;\n set_indexes[1] = 4;\n ret = method(ts, 4, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SAMPLE_SET_INDEX);\n}\n\nstatic int\ngeneral_stat_identity(\n tsk_size_t K, const double *restrict X, tsk_size_t M, double *Y, void *params)\n{\n tsk_size_t k;\n CU_ASSERT_FATAL(M == K);\n CU_ASSERT_FATAL(params == NULL);\n\n for (k = 0; k < K; k++) {\n Y[k] = X[k];\n }\n return 0;\n}\n\nstatic void\nverify_branch_general_stat_identity(tsk_treeseq_t *ts)\n{\n CU_ASSERT_FATAL(ts != NULL);\n\n int ret;\n tsk_size_t num_samples = tsk_treeseq_get_num_samples(ts);\n double *W = tsk_malloc(num_samples * sizeof(double));\n tsk_id_t *nodes = tsk_malloc(tsk_treeseq_get_num_nodes(ts) * sizeof(*nodes));\n tsk_id_t u;\n tsk_size_t num_nodes;\n double s, branch_length;\n double *sigma = tsk_malloc(tsk_treeseq_get_num_trees(ts) * sizeof(*sigma));\n tsk_tree_t tree;\n tsk_size_t j;\n CU_ASSERT_FATAL(W != NULL);\n CU_ASSERT_FATAL(nodes != NULL);\n\n for (j = 0; j < num_samples; j++) {\n W[j] = 1;\n }\n\n ret = tsk_treeseq_general_stat(ts, 1, W, 1, general_stat_identity, NULL,\n tsk_treeseq_get_num_trees(ts), tsk_treeseq_get_breakpoints(ts),\n TSK_STAT_BRANCH | TSK_STAT_POLARISED | TSK_STAT_SPAN_NORMALISE, sigma);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_tree_init(&tree, ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n\n for (ret = tsk_tree_first(&tree); ret == TSK_TREE_OK; ret = tsk_tree_next(&tree)) {\n ret = tsk_tree_preorder(&tree, nodes, &num_nodes);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n s = 0;\n for (j = 0; j < num_nodes; j++) {\n u = nodes[j];\n ret = tsk_tree_get_branch_length(&tree, u, &branch_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n s += branch_length * (double) tree.num_samples[u];\n }\n CU_ASSERT_DOUBLE_EQUAL_FATAL(sigma[tree.index], s, 1e-6);\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n free(nodes);\n tsk_tree_free(&tree);\n free(W);\n free(sigma);\n}\n\nstatic int\ngeneral_stat_sum(\n tsk_size_t K, const double *restrict X, tsk_size_t M, double *Y, void *params)\n{\n tsk_size_t k, m;\n double s = 0;\n CU_ASSERT_FATAL(params == NULL);\n\n s = 0;\n for (k = 0; k < K; k++) {\n s += X[k];\n }\n for (m = 0; m < M; m++) {\n Y[m] = s;\n }\n return 0;\n}\n\nstatic void\nverify_general_stat_dims(\n tsk_treeseq_t *ts, tsk_size_t K, tsk_size_t M, tsk_flags_t options)\n{\n int ret;\n tsk_size_t num_samples = tsk_treeseq_get_num_samples(ts);\n double *W = tsk_malloc(K * num_samples * sizeof(double));\n /* We need this much space for NODE mode; no harm for other modes. */\n double *sigma = tsk_calloc(tsk_treeseq_get_num_nodes(ts) * M, sizeof(double));\n tsk_size_t j, k;\n CU_ASSERT_FATAL(W != NULL);\n\n for (j = 0; j < num_samples; j++) {\n for (k = 0; k < K; k++) {\n W[j * K + k] = 1;\n }\n }\n ret = tsk_treeseq_general_stat(\n ts, K, W, M, general_stat_sum, NULL, 0, NULL, options, sigma);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n free(W);\n free(sigma);\n}\n\nstatic void\nverify_general_stat_windows(\n tsk_treeseq_t *ts, tsk_size_t num_windows, tsk_flags_t options)\n{\n int ret;\n tsk_size_t num_samples = tsk_treeseq_get_num_samples(ts);\n double *W = tsk_malloc(num_samples * sizeof(double));\n tsk_size_t M = 5;\n /* We need this much space for NODE mode; no harm for other modes. */\n double *sigma\n = tsk_calloc(M * tsk_treeseq_get_num_nodes(ts) * num_windows, sizeof(double));\n double *windows = tsk_malloc((num_windows + 1) * sizeof(*windows));\n double L = tsk_treeseq_get_sequence_length(ts);\n tsk_size_t j;\n CU_ASSERT_FATAL(W != NULL);\n CU_ASSERT_FATAL(sigma != NULL);\n CU_ASSERT_FATAL(windows != NULL);\n\n for (j = 0; j < num_samples; j++) {\n W[j] = 1;\n }\n windows[0] = 0;\n windows[num_windows] = L;\n for (j = 1; j < num_windows; j++) {\n windows[j] = ((double) j) * L / (double) num_windows;\n }\n ret = tsk_treeseq_general_stat(\n ts, 1, W, M, general_stat_sum, NULL, num_windows, windows, options, sigma);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n free(W);\n free(sigma);\n free(windows);\n}\n\nstatic void\nverify_default_general_stat(tsk_treeseq_t *ts)\n{\n int ret;\n tsk_size_t K = 2;\n tsk_size_t M = 1;\n tsk_size_t num_samples = tsk_treeseq_get_num_samples(ts);\n double *W = tsk_malloc(K * num_samples * sizeof(double));\n double sigma1, sigma2;\n tsk_size_t j, k;\n CU_ASSERT_FATAL(W != NULL);\n\n for (j = 0; j < num_samples; j++) {\n for (k = 0; k < K; k++) {\n W[j * K + k] = 1;\n }\n }\n ret = tsk_treeseq_general_stat(\n ts, K, W, M, general_stat_sum, NULL, 0, NULL, TSK_STAT_SITE, &sigma1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_general_stat(\n ts, K, W, M, general_stat_sum, NULL, 0, NULL, 0, &sigma2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(sigma1, sigma2);\n free(W);\n}\n\nstatic void\nverify_general_stat(tsk_treeseq_t *ts, tsk_flags_t mode)\n{\n CU_ASSERT_FATAL(ts != NULL);\n verify_general_stat_dims(ts, 4, 2, mode);\n verify_general_stat_dims(ts, 4, 2, mode | TSK_STAT_POLARISED);\n verify_general_stat_dims(ts, 1, 20, mode);\n verify_general_stat_dims(ts, 1, 20, mode | TSK_STAT_POLARISED);\n verify_general_stat_dims(ts, 100, 1, mode);\n verify_general_stat_dims(ts, 100, 1, mode | TSK_STAT_POLARISED);\n verify_general_stat_dims(ts, 10, 12, mode);\n verify_general_stat_dims(ts, 10, 12, mode | TSK_STAT_POLARISED);\n verify_general_stat_windows(ts, 1, mode);\n verify_general_stat_windows(ts, 1, mode | TSK_STAT_SPAN_NORMALISE);\n verify_general_stat_windows(ts, 2, mode);\n verify_general_stat_windows(ts, 2, mode | TSK_STAT_SPAN_NORMALISE);\n verify_general_stat_windows(ts, 3, mode);\n verify_general_stat_windows(ts, 3, mode | TSK_STAT_SPAN_NORMALISE);\n verify_general_stat_windows(ts, 10, mode);\n verify_general_stat_windows(ts, 10, mode | TSK_STAT_SPAN_NORMALISE);\n verify_general_stat_windows(ts, 100, mode);\n verify_general_stat_windows(ts, 100, mode | TSK_STAT_SPAN_NORMALISE);\n}\n\nstatic void\nverify_afs(tsk_treeseq_t *ts)\n{\n int ret;\n tsk_size_t n = tsk_treeseq_get_num_samples(ts);\n tsk_size_t sample_set_sizes[2];\n double time_windows[] = { 0, 1 };\n const tsk_id_t *samples = tsk_treeseq_get_samples(ts);\n double *result = tsk_malloc(n * n * sizeof(*result));\n\n CU_ASSERT_FATAL(sample_set_sizes != NULL);\n\n sample_set_sizes[0] = n - 2;\n sample_set_sizes[1] = 2;\n ret = tsk_treeseq_allele_frequency_spectrum(\n ts, 2, sample_set_sizes, samples, 0, NULL, 0, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_allele_frequency_spectrum(\n ts, 2, sample_set_sizes, samples, 0, NULL, 0, NULL, TSK_STAT_POLARISED, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_allele_frequency_spectrum(ts, 2, sample_set_sizes, samples, 0,\n NULL, 0, NULL, TSK_STAT_POLARISED | TSK_STAT_SPAN_NORMALISE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_allele_frequency_spectrum(ts, 2, sample_set_sizes, samples, 0,\n NULL, 0, NULL, TSK_STAT_BRANCH | TSK_STAT_POLARISED | TSK_STAT_SPAN_NORMALISE,\n result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_allele_frequency_spectrum(ts, 2, sample_set_sizes, samples, 0,\n NULL, 0, NULL, TSK_STAT_BRANCH | TSK_STAT_SPAN_NORMALISE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_allele_frequency_spectrum(ts, 2, sample_set_sizes, samples, 0,\n NULL, 1, time_windows, TSK_STAT_BRANCH | TSK_STAT_SPAN_NORMALISE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n free(result);\n}\n\nstatic void\ntest_general_stat_input_errors(void)\n{\n tsk_treeseq_t ts;\n double result;\n double W;\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n\n /* Bad input dimensions */\n ret = tsk_treeseq_general_stat(\n &ts, 0, &W, 1, general_stat_sum, NULL, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_STATE_DIMS);\n\n ret = tsk_treeseq_general_stat(\n &ts, 1, &W, 0, general_stat_sum, NULL, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_RESULT_DIMS);\n\n /* Multiple stats*/\n ret = tsk_treeseq_general_stat(&ts, 1, &W, 1, general_stat_sum, NULL, 0, NULL,\n TSK_STAT_SITE | TSK_STAT_BRANCH, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MULTIPLE_STAT_MODES);\n ret = tsk_treeseq_general_stat(&ts, 1, &W, 1, general_stat_sum, NULL, 0, NULL,\n TSK_STAT_SITE | TSK_STAT_NODE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MULTIPLE_STAT_MODES);\n ret = tsk_treeseq_general_stat(&ts, 1, &W, 1, general_stat_sum, NULL, 0, NULL,\n TSK_STAT_BRANCH | TSK_STAT_NODE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MULTIPLE_STAT_MODES);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_empty_ts_ld(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(\n &ts, 1, single_tree_ex_nodes, \"\", NULL, NULL, NULL, NULL, NULL, 0);\n\n verify_ld(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_empty_ts_mean_descendants(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(\n &ts, 1, single_tree_ex_nodes, \"\", NULL, NULL, NULL, NULL, NULL, 0);\n verify_mean_descendants(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_empty_ts_genealogical_nearest_neighbours(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(\n &ts, 1, single_tree_ex_nodes, \"\", NULL, NULL, NULL, NULL, NULL, 0);\n verify_genealogical_nearest_neighbours(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_empty_ts_general_stat(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(\n &ts, 1, single_tree_ex_nodes, \"\", NULL, NULL, NULL, NULL, NULL, 0);\n verify_branch_general_stat_identity(&ts);\n verify_default_general_stat(&ts);\n verify_general_stat(&ts, TSK_STAT_BRANCH);\n verify_general_stat(&ts, TSK_STAT_SITE);\n verify_general_stat(&ts, TSK_STAT_NODE);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_empty_ts_afs(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(\n &ts, 1, single_tree_ex_nodes, \"\", NULL, NULL, NULL, NULL, NULL, 0);\n verify_afs(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_ld(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n verify_ld(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_mean_descendants(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n verify_mean_descendants(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_genealogical_nearest_neighbours(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n verify_genealogical_nearest_neighbours(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_general_stat(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n verify_branch_general_stat_identity(&ts);\n verify_default_general_stat(&ts);\n verify_general_stat(&ts, TSK_STAT_BRANCH);\n verify_general_stat(&ts, TSK_STAT_SITE);\n verify_general_stat(&ts, TSK_STAT_NODE);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_general_stat_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n verify_branch_general_stat_errors(&ts);\n verify_site_general_stat_errors(&ts);\n verify_node_general_stat_errors(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_divergence_matrix(void)\n{\n tsk_treeseq_t ts;\n int ret;\n double result[16];\n double D_branch[16] = { 0, 2, 6, 6, 2, 0, 6, 6, 6, 6, 0, 4, 6, 6, 4, 0 };\n double D_site[16] = { 0, 1, 1, 0, 1, 0, 2, 1, 1, 2, 0, 1, 0, 1, 1, 0 };\n\n tsk_size_t sample_set_sizes[] = { 2, 2 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 0, NULL, NULL, 0, NULL, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(16, result, D_branch);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 0, NULL, NULL, 0, NULL, TSK_STAT_SITE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(16, result, D_site);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 2, sample_set_sizes, NULL, 0, NULL, TSK_STAT_SITE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 2, sample_set_sizes, NULL, 0, NULL, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n sample_set_sizes[0] = 3;\n sample_set_sizes[1] = 1;\n ret = tsk_treeseq_divergence_matrix(\n &ts, 2, sample_set_sizes, NULL, 0, NULL, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_divergence_matrix(\n &ts, 2, sample_set_sizes, NULL, 0, NULL, TSK_STAT_SITE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* assert_arrays_almost_equal(4, result, D_site); */\n\n verify_divergence_matrix(&ts, TSK_STAT_BRANCH);\n verify_divergence_matrix(&ts, TSK_STAT_BRANCH | TSK_STAT_SPAN_NORMALISE);\n verify_divergence_matrix(&ts, TSK_STAT_SITE);\n verify_divergence_matrix(&ts, TSK_STAT_SITE | TSK_STAT_SPAN_NORMALISE);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_divergence_matrix_internal_samples(void)\n{\n tsk_treeseq_t ts;\n int ret;\n double *result = malloc(16 * sizeof(double));\n double D[16] = { 0, 2, 4, 3, 2, 0, 4, 3, 4, 4, 0, 1, 3, 3, 1, 0 };\n\n const char *nodes = \"1 0 -1 -1\\n\" /* 2.00┊ 6 ┊ */\n \"1 0 -1 -1\\n\" /* ┊ ┏━┻━┓ ┊ */\n \"1 0 -1 -1\\n\" /* 1.00┊ 4 5* ┊ */\n \"0 0 -1 -1\\n\" /* ┊ ┏┻┓ ┏┻┓ ┊ */\n \"0 1 -1 -1\\n\" /* 0.00┊ 0 1 2 3 ┊ */\n \"1 1 -1 -1\\n\" /* 0 * * * 1 */\n \"0 2 -1 -1\\n\";\n const char *edges = \"0 1 4 0,1\\n\"\n \"0 1 5 2,3\\n\"\n \"0 1 6 4,5\\n\";\n /* One mutations per branch so we get the same as the branch length value */\n const char *sites = \"0.1 A\\n\"\n \"0.2 A\\n\"\n \"0.3 A\\n\"\n \"0.4 A\\n\"\n \"0.5 A\\n\"\n \"0.6 A\\n\";\n const char *mutations = \"0 0 T -1\\n\"\n \"1 1 T -1\\n\"\n \"2 2 T -1\\n\"\n \"3 3 T -1\\n\"\n \"4 4 T -1\\n\"\n \"5 5 T -1\\n\";\n tsk_id_t samples[] = { 0, 1, 2, 5 };\n tsk_size_t sizes[] = { 1, 1, 1, 1 };\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 0, NULL, NULL, 0, NULL, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(16, result, D);\n ret = tsk_treeseq_divergence_matrix(\n &ts, 0, NULL, NULL, 0, NULL, TSK_STAT_SITE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(16, result, D);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 4, sizes, samples, 0, NULL, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(16, result, D);\n ret = tsk_treeseq_divergence_matrix(\n &ts, 4, sizes, samples, 0, NULL, TSK_STAT_SITE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(16, result, D);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 4, NULL, samples, 0, NULL, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(16, result, D);\n ret = tsk_treeseq_divergence_matrix(\n &ts, 4, NULL, samples, 0, NULL, TSK_STAT_SITE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(16, result, D);\n\n verify_divergence_matrix(&ts, TSK_STAT_BRANCH);\n verify_divergence_matrix(&ts, TSK_STAT_BRANCH | TSK_STAT_SPAN_NORMALISE);\n verify_divergence_matrix(&ts, TSK_STAT_SITE);\n verify_divergence_matrix(&ts, TSK_STAT_SITE | TSK_STAT_SPAN_NORMALISE);\n\n tsk_treeseq_free(&ts);\n free(result);\n}\n\nstatic void\ntest_single_tree_divergence_matrix_multi_root(void)\n{\n tsk_treeseq_t ts;\n int ret;\n double result[16];\n double D_branch[16] = { 0, 2, 3, 3, 2, 0, 3, 3, 3, 3, 0, 4, 3, 3, 4, 0 };\n\n const char *nodes = \"1 0 -1 -1\\n\"\n \"1 0 -1 -1\\n\" /* 2.00┊ 5 ┊ */\n \"1 0 -1 -1\\n\" /* 1.00┊ 4 ┊ */\n \"1 0 -1 -1\\n\" /* ┊ ┏┻┓ ┏┻┓ ┊ */\n \"0 1 -1 -1\\n\" /* 0.00┊ 0 1 2 3 ┊ */\n \"0 2 -1 -1\\n\"; /* 0 * * * * 1 */\n const char *edges = \"0 1 4 0,1\\n\"\n \"0 1 5 2,3\\n\";\n /* Two mutations per branch */\n const char *sites = \"0.1 A\\n\"\n \"0.2 A\\n\"\n \"0.3 A\\n\"\n \"0.4 A\\n\";\n const char *mutations = \"0 0 B -1\\n\"\n \"0 0 C 0\\n\"\n \"1 1 B -1\\n\"\n \"1 1 C 2\\n\"\n \"2 2 B -1\\n\"\n \"2 2 C 4\\n\"\n \"2 2 D 5\\n\"\n \"2 2 E 6\\n\"\n \"3 3 B -1\\n\"\n \"3 3 C 8\\n\"\n \"3 3 D 9\\n\"\n \"3 3 E 10\\n\";\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 0, NULL, NULL, 0, NULL, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(16, result, D_branch);\n\n verify_divergence_matrix(&ts, TSK_STAT_BRANCH);\n verify_divergence_matrix(&ts, TSK_STAT_BRANCH | TSK_STAT_SPAN_NORMALISE);\n verify_divergence_matrix(&ts, TSK_STAT_SITE);\n verify_divergence_matrix(&ts, TSK_STAT_SITE | TSK_STAT_SPAN_NORMALISE);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_ld(void)\n{\n tsk_treeseq_t ts;\n tsk_ld_calc_t ld_calc;\n double r2[3];\n tsk_size_t num_r2_values;\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_ld(&ts);\n\n /* Check early exit corner cases */\n ret = tsk_ld_calc_init(&ld_calc, &ts);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_ld_calc_get_r2_array(\n &ld_calc, 0, TSK_DIR_FORWARD, 1, DBL_MAX, r2, &num_r2_values);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(num_r2_values, 1);\n\n ret = tsk_ld_calc_get_r2_array(\n &ld_calc, 2, TSK_DIR_REVERSE, 1, DBL_MAX, r2, &num_r2_values);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(num_r2_values, 1);\n\n tsk_ld_calc_free(&ld_calc);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_mean_descendants(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_mean_descendants(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_genealogical_nearest_neighbours(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_genealogical_nearest_neighbours(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_general_stat(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_branch_general_stat_identity(&ts);\n verify_default_general_stat(&ts);\n verify_general_stat(&ts, TSK_STAT_BRANCH);\n verify_general_stat(&ts, TSK_STAT_SITE);\n verify_general_stat(&ts, TSK_STAT_NODE);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_general_stat_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_branch_general_stat_errors(&ts);\n verify_site_general_stat_errors(&ts);\n verify_node_general_stat_errors(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_diversity_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_one_way_stat_func_errors(&ts, tsk_treeseq_diversity);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_diversity(void)\n{\n tsk_treeseq_t ts;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes = 4;\n double pi;\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n ret = tsk_treeseq_diversity(\n &ts, 1, &sample_set_sizes, samples, 0, NULL, TSK_STAT_SITE, &pi);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(pi, 1.5, 1e-6);\n\n /* A sample set size of 1 leads to NaN */\n sample_set_sizes = 1;\n ret = tsk_treeseq_diversity(\n &ts, 1, &sample_set_sizes, samples, 0, NULL, TSK_STAT_SITE, &pi);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT(tsk_isnan(pi));\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_trait_covariance_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_one_way_weighted_func_errors(&ts, tsk_treeseq_trait_covariance);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_trait_covariance(void)\n{\n tsk_treeseq_t ts;\n double result;\n double *weights;\n tsk_size_t j;\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n weights = tsk_malloc(4 * sizeof(double));\n weights[0] = weights[1] = 0.0;\n weights[2] = weights[3] = 1.0;\n\n ret = tsk_treeseq_trait_covariance(&ts, 1, weights, 0, NULL, TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(result, 1.0 / 12.0, 1e-6);\n\n /* weights of 0 leads to 0 */\n for (j = 0; j < 4; j++) {\n weights[j] = 0.0;\n }\n ret = tsk_treeseq_trait_covariance(&ts, 1, weights, 0, NULL, TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(result, 0.0, 1e-6);\n\n tsk_treeseq_free(&ts);\n free(weights);\n}\n\nstatic void\ntest_paper_ex_trait_correlation_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_one_way_weighted_func_errors(&ts, tsk_treeseq_trait_correlation);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_trait_correlation(void)\n{\n tsk_treeseq_t ts;\n double result;\n double *weights;\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n weights = tsk_malloc(4 * sizeof(double));\n weights[0] = weights[1] = 0.0;\n weights[2] = weights[3] = 1.0;\n\n ret = tsk_treeseq_trait_correlation(\n &ts, 1, weights, 0, NULL, TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(result, 1.0, 1e-6);\n\n tsk_treeseq_free(&ts);\n free(weights);\n}\n\nstatic void\ntest_paper_ex_trait_linear_model_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_one_way_weighted_covariate_func_errors(&ts, tsk_treeseq_trait_linear_model);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_trait_linear_model(void)\n{\n tsk_treeseq_t ts;\n double result;\n double *weights;\n double *covariates;\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n weights = tsk_malloc(4 * sizeof(double));\n covariates = tsk_malloc(8 * sizeof(double));\n weights[0] = weights[1] = 0.0;\n weights[2] = weights[3] = 1.0;\n covariates[0] = covariates[1] = 0.0;\n covariates[2] = covariates[3] = 1.0;\n covariates[4] = covariates[6] = 0.0;\n covariates[5] = covariates[7] = 1.0;\n\n ret = tsk_treeseq_trait_linear_model(\n &ts, 1, weights, 2, covariates, 0, NULL, TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(result, 0.0, 1e-6);\n\n tsk_treeseq_free(&ts);\n free(weights);\n free(covariates);\n}\n\nstatic void\ntest_paper_ex_segregating_sites_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_one_way_stat_func_errors(&ts, tsk_treeseq_segregating_sites);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_segregating_sites(void)\n{\n tsk_treeseq_t ts;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes = 4;\n double segsites;\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n ret = tsk_treeseq_segregating_sites(\n &ts, 1, &sample_set_sizes, samples, 0, NULL, TSK_STAT_SITE, &segsites);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(segsites, 3.0, 1e-6);\n\n /* A sample set size of 1 leads to 0 */\n sample_set_sizes = 1;\n ret = tsk_treeseq_segregating_sites(\n &ts, 1, &sample_set_sizes, samples, 0, NULL, TSK_STAT_SITE, &segsites);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(segsites, 0.0, 1e-6);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_Y1_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_one_way_stat_func_errors(&ts, tsk_treeseq_Y1);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_Y1(void)\n{\n tsk_treeseq_t ts;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes = 4;\n double result;\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n ret = tsk_treeseq_Y1(&ts, 1, &sample_set_sizes, samples, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* A sample set size of < 2 leads to NaN */\n sample_set_sizes = 1;\n ret = tsk_treeseq_Y1(&ts, 1, &sample_set_sizes, samples, 0, NULL, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT(tsk_isnan(result));\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_divergence_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_two_way_stat_func_errors(&ts, tsk_treeseq_divergence, 0);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_divergence(void)\n{\n tsk_treeseq_t ts;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes[] = { 2, 2 };\n tsk_id_t set_indexes[] = { 0, 1 };\n double result;\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n ret = tsk_treeseq_divergence(&ts, 2, sample_set_sizes, samples, 1, set_indexes, 0,\n NULL, TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* sample_set[0] size = 1 with indexes = (0, 0) leads to NaN */\n sample_set_sizes[0] = 1;\n set_indexes[1] = 0;\n ret = tsk_treeseq_divergence(&ts, 2, sample_set_sizes, samples, 1, set_indexes, 0,\n NULL, TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT(tsk_isnan(result));\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_genetic_relatedness(void)\n{\n tsk_treeseq_t ts;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes[] = { 2, 2 };\n tsk_id_t set_indexes[] = { 0, 0 };\n double result;\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n ret = tsk_treeseq_genetic_relatedness(&ts, 2, sample_set_sizes, samples, 1,\n set_indexes, 0, NULL, TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_genetic_relatedness(&ts, 2, sample_set_sizes, samples, 1,\n set_indexes, 0, NULL, TSK_STAT_SITE | TSK_STAT_NONCENTRED, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_genetic_relatedness_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_two_way_stat_func_errors(&ts, tsk_treeseq_genetic_relatedness, 0);\n verify_two_way_stat_func_errors(\n &ts, tsk_treeseq_genetic_relatedness, TSK_STAT_NONCENTRED);\n verify_two_way_stat_func_errors(\n &ts, tsk_treeseq_genetic_relatedness, TSK_STAT_POLARISED);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_genetic_relatedness_weighted(void)\n{\n tsk_treeseq_t ts;\n double weights[] = { 1.2, 0.1, 0.0, 0.0, 3.4, 5.0, 1.0, -1.0 };\n tsk_id_t indexes[] = { 0, 0, 0, 1 };\n double result[100];\n tsk_size_t num_weights;\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n for (num_weights = 1; num_weights < 3; num_weights++) {\n ret = tsk_treeseq_genetic_relatedness_weighted(\n &ts, num_weights, weights, 2, indexes, 0, NULL, result, TSK_STAT_SITE);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_genetic_relatedness_weighted(\n &ts, num_weights, weights, 2, indexes, 0, NULL, result, TSK_STAT_BRANCH);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_genetic_relatedness_weighted(\n &ts, num_weights, weights, 2, indexes, 0, NULL, result, TSK_STAT_NODE);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_genetic_relatedness_weighted(&ts, num_weights, weights, 2,\n indexes, 0, NULL, result, TSK_STAT_SITE | TSK_STAT_NONCENTRED);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_genetic_relatedness_weighted(&ts, num_weights, weights, 2,\n indexes, 0, NULL, result, TSK_STAT_BRANCH | TSK_STAT_NONCENTRED);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_genetic_relatedness_weighted(&ts, num_weights, weights, 2,\n indexes, 0, NULL, result, TSK_STAT_NODE | TSK_STAT_NONCENTRED);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n }\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_genetic_relatedness_weighted_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_two_way_weighted_stat_func_errors(\n &ts, tsk_treeseq_genetic_relatedness_weighted, 0);\n verify_two_way_weighted_stat_func_errors(\n &ts, tsk_treeseq_genetic_relatedness_weighted, TSK_STAT_NONCENTRED);\n verify_two_way_weighted_stat_func_errors(\n &ts, tsk_treeseq_genetic_relatedness_weighted, TSK_STAT_POLARISED);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_empty_genetic_relatedness_vector(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_size_t num_samples;\n double *weights, *result, *result2;\n tsk_size_t j;\n tsk_size_t num_weights = 2;\n double windows[] = { 0, 0 };\n\n tsk_treeseq_from_text(\n &ts, 1, single_tree_ex_nodes, \"\", NULL, NULL, NULL, NULL, NULL, 0);\n num_samples = tsk_treeseq_get_num_samples(&ts);\n windows[1] = tsk_treeseq_get_sequence_length(&ts);\n weights = tsk_malloc(num_weights * num_samples * sizeof(double));\n result = tsk_malloc(num_weights * num_samples * sizeof(double));\n result2 = tsk_malloc(num_weights * num_samples * sizeof(double));\n for (j = 0; j < num_samples; j++) {\n weights[j] = 1.0;\n }\n for (j = 0; j < num_samples; j++) {\n weights[j + num_samples] = (float) j;\n }\n\n ret = tsk_treeseq_genetic_relatedness_vector(\n &ts, num_weights, weights, 1, windows, num_samples, ts.samples, result, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_genetic_relatedness_vector(&ts, num_weights, weights, 1, windows,\n num_samples, ts.samples, result, TSK_STAT_NONCENTRED);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n windows[0] = 0.5 * tsk_treeseq_get_sequence_length(&ts);\n windows[1] = 0.75 * tsk_treeseq_get_sequence_length(&ts);\n ret = tsk_treeseq_genetic_relatedness_vector(\n &ts, num_weights, weights, 1, windows, num_samples, ts.samples, result, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_genetic_relatedness_vector(&ts, num_weights, weights, 1, windows,\n num_samples, ts.samples, result2, TSK_STAT_SPAN_NORMALISE);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < num_samples * num_weights; j++) {\n CU_ASSERT_EQUAL_FATAL(result[j] / (windows[1] - windows[0]), result2[j]);\n }\n\n tsk_treeseq_free(&ts);\n free(weights);\n free(result);\n free(result2);\n}\n\nstatic void\nverify_genetic_relatedness_vector(\n tsk_treeseq_t *ts, tsk_size_t num_weights, tsk_size_t num_windows)\n{\n int ret;\n tsk_size_t num_samples;\n double *weights, *result;\n tsk_size_t j, k;\n double *windows = tsk_malloc((num_windows + 1) * sizeof(*windows));\n double L = tsk_treeseq_get_sequence_length(ts);\n\n windows[0] = 0;\n windows[num_windows] = L;\n for (j = 1; j < num_windows; j++) {\n windows[j] = ((double) j) * L / (double) num_windows;\n }\n num_samples = tsk_treeseq_get_num_samples(ts);\n\n weights = tsk_malloc(num_weights * num_samples * sizeof(*weights));\n result = tsk_malloc(num_windows * num_weights * num_samples * sizeof(*result));\n for (j = 0; j < num_samples; j++) {\n for (k = 0; k < num_weights; k++) {\n weights[j + k * num_samples] = 1.0 + (double) k;\n }\n }\n\n ret = tsk_treeseq_genetic_relatedness_vector(ts, num_weights, weights, num_windows,\n windows, num_samples, ts->samples, result, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n windows[0] = windows[1] / 2;\n if (num_windows > 1) {\n windows[num_windows - 1]\n = windows[num_windows - 2] + (L / (double) (2 * num_windows));\n }\n ret = tsk_treeseq_genetic_relatedness_vector(ts, num_weights, weights, num_windows,\n windows, num_samples, ts->samples, result, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_genetic_relatedness_vector(ts, num_weights, weights, num_windows,\n windows, num_samples, ts->samples, result, TSK_STAT_NONCENTRED);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_set_debug_stream(_devnull);\n ret = tsk_treeseq_genetic_relatedness_vector(ts, num_weights, weights, num_windows,\n windows, num_samples, ts->samples, result, TSK_DEBUG);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_set_debug_stream(stdout);\n\n free(windows);\n free(weights);\n free(result);\n}\n\nstatic void\ntest_paper_ex_genetic_relatedness_vector(void)\n{\n tsk_treeseq_t ts;\n double gap;\n\n for (gap = 0.0; gap < 2.0; gap += 1.0) {\n tsk_treeseq_from_text(&ts, 10 + gap, paper_ex_nodes, paper_ex_edges, NULL,\n paper_ex_sites, paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n tsk_size_t j, k;\n for (j = 1; j < 3; j++) {\n for (k = 1; k < 3; k++) {\n verify_genetic_relatedness_vector(&ts, j, k);\n }\n }\n tsk_treeseq_free(&ts);\n }\n}\n\nstatic void\ntest_paper_ex_genetic_relatedness_vector_errors(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_size_t num_samples;\n double *weights, *result;\n tsk_size_t j;\n tsk_size_t num_windows = 2;\n tsk_size_t num_weights = 2;\n double windows[] = { 0, 0, 0 };\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n num_samples = tsk_treeseq_get_num_samples(&ts);\n\n weights = tsk_malloc(num_weights * num_samples * sizeof(double));\n result = tsk_malloc(num_windows * num_weights * num_samples * sizeof(double));\n for (j = 0; j < num_samples; j++) {\n weights[j] = 1.0;\n }\n for (j = 0; j < num_samples; j++) {\n weights[j + num_samples] = (float) j;\n }\n\n /* Window errors */\n ret = tsk_treeseq_genetic_relatedness_vector(\n &ts, 1, weights, 0, windows, num_samples, ts.samples, result, TSK_STAT_BRANCH);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_NUM_WINDOWS);\n ret = tsk_treeseq_genetic_relatedness_vector(\n &ts, 1, weights, 0, NULL, num_samples, ts.samples, result, TSK_STAT_BRANCH);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_NUM_WINDOWS);\n\n ret = tsk_treeseq_genetic_relatedness_vector(\n &ts, 1, weights, 2, windows, num_samples, ts.samples, result, TSK_STAT_BRANCH);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n windows[0] = -1;\n ret = tsk_treeseq_genetic_relatedness_vector(\n &ts, 1, weights, 2, windows, num_samples, ts.samples, result, TSK_STAT_BRANCH);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n windows[0] = 12;\n ret = tsk_treeseq_genetic_relatedness_vector(\n &ts, 1, weights, 2, windows, num_samples, ts.samples, result, TSK_STAT_BRANCH);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n windows[0] = 0;\n windows[2] = 12;\n ret = tsk_treeseq_genetic_relatedness_vector(\n &ts, 1, weights, 2, windows, num_samples, ts.samples, result, TSK_STAT_BRANCH);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n /* unsupported mode errors */\n windows[0] = 0.0;\n windows[1] = 5.0;\n windows[2] = 10.0;\n ret = tsk_treeseq_genetic_relatedness_vector(&ts, num_weights, weights, 2, windows,\n num_samples, ts.samples, result, TSK_STAT_SITE);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSUPPORTED_STAT_MODE);\n ret = tsk_treeseq_genetic_relatedness_vector(&ts, num_weights, weights, 2, windows,\n num_samples, ts.samples, result, TSK_STAT_NODE);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSUPPORTED_STAT_MODE);\n\n tsk_treeseq_free(&ts);\n free(weights);\n free(result);\n}\n\nstatic void\ntest_paper_ex_genetic_relatedness_vector_node_errors(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_size_t num_samples;\n double *weights, *result;\n tsk_size_t j;\n tsk_size_t num_weights = 2;\n tsk_size_t num_windows = 2;\n double windows[] = { 1, 1.5, 2 };\n tsk_size_t num_nodes = 3;\n const tsk_id_t good_nodes[] = { 1, 0, 2 };\n const tsk_id_t bad_nodes1[] = { 1, -1, 2 };\n const tsk_id_t bad_nodes2[] = { 1, 100, 2 };\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n num_samples = tsk_treeseq_get_num_samples(&ts);\n\n weights = tsk_malloc(num_weights * num_samples * sizeof(double));\n result = tsk_malloc(num_windows * num_weights * num_nodes * sizeof(double));\n for (j = 0; j < num_samples; j++) {\n weights[j] = 1.0;\n }\n for (j = 0; j < num_samples; j++) {\n weights[j + num_samples] = (float) j;\n }\n\n /* node errors */\n ret = tsk_treeseq_genetic_relatedness_vector(&ts, num_weights, weights, 2, windows,\n num_nodes, good_nodes, result, TSK_STAT_BRANCH);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_genetic_relatedness_vector(&ts, num_weights, weights, 2, windows,\n num_nodes, bad_nodes1, result, TSK_STAT_BRANCH);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_treeseq_genetic_relatedness_vector(&ts, num_weights, weights, 2, windows,\n num_nodes, bad_nodes2, result, TSK_STAT_BRANCH);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n tsk_treeseq_free(&ts);\n free(weights);\n free(result);\n}\n\nstatic void\ntest_paper_ex_Y2_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_two_way_stat_func_errors(&ts, tsk_treeseq_Y2, 0);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_Y2(void)\n{\n tsk_treeseq_t ts;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes[] = { 2, 2 };\n tsk_id_t set_indexes[] = { 0, 1 };\n double result;\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n ret = tsk_treeseq_Y2(&ts, 2, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* sample_set_size of 1 leads to NaN */\n sample_set_sizes[1] = 1;\n ret = tsk_treeseq_Y2(&ts, 2, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT(tsk_isnan(result));\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_f2_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_two_way_stat_func_errors(&ts, tsk_treeseq_f2, 0);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_f2(void)\n{\n tsk_treeseq_t ts;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes[] = { 2, 2 };\n tsk_id_t set_indexes[] = { 0, 1 };\n double result;\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n ret = tsk_treeseq_f2(&ts, 2, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* sample_set_size of 1 leads to NaN */\n sample_set_sizes[0] = 1;\n ret = tsk_treeseq_f2(&ts, 2, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT(tsk_isnan(result));\n\n /* sample_set_size of 1 leads to NaN */\n sample_set_sizes[0] = 2;\n sample_set_sizes[1] = 1;\n ret = tsk_treeseq_f2(&ts, 2, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT(tsk_isnan(result));\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_Y3_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_three_way_stat_func_errors(&ts, tsk_treeseq_Y3);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_Y3(void)\n{\n tsk_treeseq_t ts;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes[] = { 2, 1, 1 };\n tsk_id_t set_indexes[] = { 0, 1, 2 };\n double result;\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n ret = tsk_treeseq_Y3(&ts, 3, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_f3_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_three_way_stat_func_errors(&ts, tsk_treeseq_f3);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_f3(void)\n{\n tsk_treeseq_t ts;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes[] = { 2, 1, 1 };\n tsk_id_t set_indexes[] = { 0, 1, 2 };\n double result;\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n ret = tsk_treeseq_f3(&ts, 3, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* sample_set_size of 1 leads to NaN */\n sample_set_sizes[0] = 1;\n ret = tsk_treeseq_f3(&ts, 3, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT(tsk_isnan(result));\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_f4_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_four_way_stat_func_errors(&ts, tsk_treeseq_f4);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_f4(void)\n{\n tsk_treeseq_t ts;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes[] = { 1, 1, 1, 1 };\n tsk_id_t set_indexes[] = { 0, 1, 2, 3 };\n double result;\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n ret = tsk_treeseq_f4(&ts, 4, sample_set_sizes, samples, 1, set_indexes, 0, NULL,\n TSK_STAT_SITE, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_afs_errors(void)\n{\n tsk_treeseq_t ts;\n tsk_size_t sample_set_sizes[] = { 2, 2 };\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n double result[10]; /* not thinking too hard about the actual value needed */\n double time_windows[] = { 0, 1 };\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n verify_one_way_stat_func_errors_tw(&ts, tsk_treeseq_allele_frequency_spectrum);\n\n ret = tsk_treeseq_allele_frequency_spectrum(\n &ts, 2, sample_set_sizes, samples, 0, NULL, 0, NULL, TSK_STAT_NODE, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSUPPORTED_STAT_MODE);\n\n ret = tsk_treeseq_allele_frequency_spectrum(&ts, 2, sample_set_sizes, samples, 0,\n NULL, 0, NULL, TSK_STAT_BRANCH | TSK_STAT_SITE, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MULTIPLE_STAT_MODES);\n\n ret = tsk_treeseq_allele_frequency_spectrum(&ts, 2, sample_set_sizes, samples, 0,\n NULL, 1, time_windows, TSK_STAT_SITE, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSUPPORTED_STAT_MODE);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_afs(void)\n{\n tsk_treeseq_t ts;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sample_set_sizes[] = { 4, 0 };\n double result[25];\n int ret;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n /* we have two singletons and one tripleton */\n\n ret = tsk_treeseq_allele_frequency_spectrum(\n &ts, 1, sample_set_sizes, samples, 0, NULL, 0, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result[0], 0);\n CU_ASSERT_EQUAL_FATAL(result[1], 3.0);\n CU_ASSERT_EQUAL_FATAL(result[2], 0);\n\n ret = tsk_treeseq_allele_frequency_spectrum(\n &ts, 1, sample_set_sizes, samples, 0, NULL, 0, NULL, TSK_STAT_POLARISED, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result[0], 0);\n CU_ASSERT_EQUAL_FATAL(result[1], 2.0);\n CU_ASSERT_EQUAL_FATAL(result[2], 0);\n CU_ASSERT_EQUAL_FATAL(result[3], 1.0);\n CU_ASSERT_EQUAL_FATAL(result[4], 0);\n\n verify_afs(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_divergence_matrix(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n verify_divergence_matrix(&ts, TSK_STAT_BRANCH);\n verify_divergence_matrix(&ts, TSK_STAT_BRANCH | TSK_STAT_SPAN_NORMALISE);\n verify_divergence_matrix(&ts, TSK_STAT_SITE);\n verify_divergence_matrix(&ts, TSK_STAT_SITE | TSK_STAT_SPAN_NORMALISE);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_unary_ex_afs(void)\n{\n tsk_treeseq_t ts;\n tsk_id_t samples[] = { 0, 2, 3 };\n tsk_size_t sample_set_sizes[] = { 3, 0 };\n double result[25];\n int ret;\n\n tsk_treeseq_from_text(&ts, 100, unary_ex_nodes, unary_ex_edges, NULL, unary_ex_sites,\n unary_ex_mutations, NULL, NULL, 0);\n /* we have a singleton and a doubleton */\n\n ret = tsk_treeseq_allele_frequency_spectrum(\n &ts, 1, sample_set_sizes, samples, 0, NULL, 0, NULL, TSK_STAT_POLARISED, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result[0], 0);\n CU_ASSERT_EQUAL_FATAL(result[1], 1.0);\n CU_ASSERT_EQUAL_FATAL(result[2], 1.0);\n CU_ASSERT_EQUAL_FATAL(result[3], 0.0);\n\n ret = tsk_treeseq_allele_frequency_spectrum(&ts, 1, sample_set_sizes, samples, 0,\n NULL, 0, NULL, TSK_STAT_BRANCH | TSK_STAT_POLARISED, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE_FATAL(result[0] > 0);\n CU_ASSERT_TRUE_FATAL(result[1] > 0);\n CU_ASSERT_TRUE_FATAL(result[2] > 0);\n CU_ASSERT_EQUAL_FATAL(result[3], 0.0);\n\n verify_afs(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_nonbinary_ex_ld(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 100, nonbinary_ex_nodes, nonbinary_ex_edges, NULL,\n nonbinary_ex_sites, nonbinary_ex_mutations, NULL, NULL, 0);\n verify_ld(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_nonbinary_ex_mean_descendants(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 100, nonbinary_ex_nodes, nonbinary_ex_edges, NULL,\n nonbinary_ex_sites, nonbinary_ex_mutations, NULL, NULL, 0);\n verify_mean_descendants(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_nonbinary_ex_genealogical_nearest_neighbours(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 100, nonbinary_ex_nodes, nonbinary_ex_edges, NULL,\n nonbinary_ex_sites, nonbinary_ex_mutations, NULL, NULL, 0);\n verify_genealogical_nearest_neighbours(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_nonbinary_ex_general_stat(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 100, nonbinary_ex_nodes, nonbinary_ex_edges, NULL,\n nonbinary_ex_sites, nonbinary_ex_mutations, NULL, NULL, 0);\n verify_branch_general_stat_identity(&ts);\n verify_default_general_stat(&ts);\n verify_general_stat(&ts, TSK_STAT_BRANCH);\n verify_general_stat(&ts, TSK_STAT_SITE);\n verify_general_stat(&ts, TSK_STAT_NODE);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_nonbinary_ex_general_stat_errors(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 100, nonbinary_ex_nodes, nonbinary_ex_edges, NULL,\n nonbinary_ex_sites, nonbinary_ex_mutations, NULL, NULL, 0);\n verify_branch_general_stat_errors(&ts);\n verify_site_general_stat_errors(&ts);\n verify_node_general_stat_errors(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_caterpillar_tree_ld(void)\n{\n tsk_treeseq_t *ts = caterpillar_tree(50, 20, 1);\n tsk_ld_calc_t ld_calc;\n double r2[20];\n tsk_size_t num_r2_values;\n int ret = tsk_ld_calc_init(&ld_calc, ts);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n verify_ld(ts);\n\n ret = tsk_ld_calc_get_r2_array(\n &ld_calc, 0, TSK_DIR_FORWARD, 5, DBL_MAX, r2, &num_r2_values);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(num_r2_values, 5);\n\n ret = tsk_ld_calc_get_r2_array(\n &ld_calc, 10, TSK_DIR_REVERSE, 5, DBL_MAX, r2, &num_r2_values);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(num_r2_values, 5);\n\n tsk_ld_calc_free(&ld_calc);\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\ntest_ld_multi_mutations(void)\n{\n tsk_treeseq_t *ts = caterpillar_tree(4, 2, 2);\n tsk_ld_calc_t ld_calc;\n double r2;\n int ret = tsk_ld_calc_init(&ld_calc, ts);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_ld_calc_get_r2(&ld_calc, 0, 1, &r2);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_ONLY_INFINITE_SITES);\n\n tsk_ld_calc_free(&ld_calc);\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\ntest_ld_silent_mutations(void)\n{\n tsk_treeseq_t *base_ts = caterpillar_tree(4, 2, 1);\n tsk_table_collection_t tables;\n tsk_treeseq_t ts;\n tsk_ld_calc_t ld_calc;\n double r2;\n int ret = tsk_table_collection_copy(base_ts->tables, &tables, 0);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.mutations.derived_state[1] = '0';\n\n ret = tsk_treeseq_init(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_ld_calc_init(&ld_calc, &ts);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_ld_calc_get_r2(&ld_calc, 0, 1, &r2);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SILENT_MUTATIONS_NOT_SUPPORTED);\n tsk_ld_calc_free(&ld_calc);\n tsk_treeseq_free(&ts);\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(base_ts);\n free(base_ts);\n}\n\nstatic void\ntest_paper_ex_two_site(void)\n{\n tsk_treeseq_t ts;\n double result[27];\n tsk_size_t s, result_size, num_sample_sets;\n int ret;\n\n double truth_one_set[9] = { 1, 0.1111111111111111, 0.1111111111111111,\n 0.1111111111111111, 1, 1, 0.1111111111111111, 1, 1 };\n double truth_two_sets[18] = { 1, 1, 0.1111111111111111, 0.1111111111111111,\n 0.1111111111111111, 0.1111111111111111, 0.1111111111111111, 0.1111111111111111,\n 1, 1, 1, 1, 0.1111111111111111, 0.1111111111111111, 1, 1, 1, 1 };\n double truth_three_sets[27] = { 1, 1, NAN, 0.1111111111111111, 0.1111111111111111,\n NAN, 0.1111111111111111, 0.1111111111111111, NAN, 0.1111111111111111,\n 0.1111111111111111, NAN, 1, 1, 1, 1, 1, 1, 0.1111111111111111,\n 0.1111111111111111, NAN, 1, 1, 1, 1, 1, 1 };\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n double truth_three_index_tuples[27] = { 1, 1, NAN, 0.1111111111111111,\n 0.1111111111111111, NAN, 0.1111111111111111, 0.1111111111111111, NAN,\n 0.1111111111111111, 0.1111111111111111, NAN, 1, 1, 1, 1, 1, 1,\n 0.1111111111111111, 0.1111111111111111, NAN, 1, 1, 1, 1, 1, 1 };\n\n tsk_size_t sample_set_sizes[3], num_index_tuples;\n tsk_id_t sample_sets[ts.num_samples * 3], index_tuples[2 * 3] = { 0, 1, 0, 0, 0, 2 };\n tsk_size_t num_sites = ts.tables->sites.num_rows;\n tsk_id_t *sites = tsk_malloc(num_sites * sizeof(*sites));\n\n // First sample set contains all of the samples\n sample_set_sizes[0] = ts.num_samples;\n num_sample_sets = 1;\n for (s = 0; s < ts.num_samples; s++) {\n sample_sets[s] = (tsk_id_t) s;\n }\n for (s = 0; s < num_sites; s++) {\n sites[s] = (tsk_id_t) s;\n }\n\n result_size = num_sites * num_sites;\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n sites, NULL, num_sites, sites, NULL, 0, result);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size * num_sample_sets, result, truth_one_set);\n\n // Second sample set contains all of the samples\n sample_set_sizes[1] = ts.num_samples;\n num_sample_sets = 2;\n for (s = ts.num_samples; s < ts.num_samples * 2; s++) {\n sample_sets[s] = (tsk_id_t) s - (tsk_id_t) ts.num_samples;\n }\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n sites, NULL, num_sites, sites, NULL, 0, result);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size * num_sample_sets, result, truth_two_sets);\n\n // Third sample set contains the first two samples\n sample_set_sizes[2] = 2;\n num_sample_sets = 3;\n for (s = ts.num_samples * 2; s < (ts.num_samples * 3) - 2; s++) {\n sample_sets[s] = (tsk_id_t) s - (tsk_id_t) ts.num_samples * 2;\n }\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n sites, NULL, num_sites, sites, NULL, 0, result);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal_nan(\n result_size * num_sample_sets, result, truth_three_sets);\n\n // Two-way stats: we'll reuse all sample sets from the first 3 tests\n num_sample_sets = 3;\n\n num_index_tuples = 1;\n // We'll compute r2 between sample set 0 and sample set 1\n tsk_memset(result, 0, sizeof(*result) * result_size * num_index_tuples);\n ret = tsk_treeseq_r2_ij(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_index_tuples, index_tuples, num_sites, sites, NULL, num_sites, sites, NULL,\n 0, result);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size * num_index_tuples, result, truth_one_set);\n\n // Compare sample sets [(0, 1), (0, 0)]\n num_index_tuples = 2;\n tsk_memset(result, 0, sizeof(*result) * result_size * num_index_tuples);\n ret = tsk_treeseq_r2_ij(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_index_tuples, index_tuples, num_sites, sites, NULL, num_sites, sites, NULL,\n 0, result);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size * num_index_tuples, result, truth_two_sets);\n\n // Compare sample sets [(0, 1), (0, 0), (0, 2)]\n num_index_tuples = 3;\n tsk_memset(result, 0, sizeof(*result) * result_size * num_index_tuples);\n ret = tsk_treeseq_r2_ij(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_index_tuples, index_tuples, num_sites, sites, NULL, num_sites, sites, NULL,\n 0, result);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal_nan(\n result_size * num_index_tuples, result, truth_three_index_tuples);\n\n tsk_treeseq_free(&ts);\n tsk_safe_free(sites);\n}\n\nstatic void\ntest_paper_ex_two_branch(void)\n{\n int ret;\n tsk_treeseq_t ts;\n double result[27];\n tsk_size_t i, result_size, num_sample_sets;\n tsk_flags_t options = 0;\n double truth_one_set[9] = { 0.008890640625, 0.004624203125, 0.005215703125,\n 0.004624203125, 0.003737578125, 0.004377078125, 0.005215703125,\n 0.004377078124999999, 0.005160578124999998 };\n double truth_two_sets[18] = { 0.008890640625, 0.008890640625, 0.004624203125,\n 0.004624203125, 0.005215703125, 0.005215703125, 0.004624203125, 0.004624203125,\n 0.003737578125, 0.003737578125, 0.004377078125, 0.004377078125, 0.005215703125,\n 0.005215703125, 0.004377078124999999, 0.004377078124999999, 0.005160578124999998,\n 0.005160578124999998 };\n double truth_three_sets[27]\n = { 0.008890640625, 0.008890640625, 0.007225, 0.004624203125000001,\n 0.004624203125, 0.007225, 0.005215703125000002, 0.005215703125, 0.008585,\n 0.004624203125, 0.004624203125, 0.007225, 0.003737578125, 0.003737578125,\n 0.007225, 0.004377078125, 0.004377078125, 0.008585, 0.005215703125,\n 0.005215703125, 0.008585, 0.004377078124999999, 0.004377078124999999,\n 0.008585, 0.005160578124999998, 0.005160578124999998, 0.010201 };\n double truth_positions_subset_1[12] = { 0.008890640625, 0.008890640625, 0.007225,\n 0.008890640625, 0.008890640625, 0.007225, 0.008890640625, 0.008890640625,\n 0.007225, 0.008890640625, 0.008890640625, 0.007225 };\n double truth_positions_subset_2[12] = { 0.003737578125, 0.003737578125, 0.007225,\n 0.003737578125, 0.003737578125, 0.007225, 0.003737578125, 0.003737578125,\n 0.007225, 0.003737578125, 0.003737578125, 0.007225 };\n double truth_positions_subset_3[12] = { 0.005160578125, 0.005160578125, 0.010201,\n 0.005160578125, 0.005160578125, 0.010201, 0.005160578125, 0.005160578125,\n 0.010201, 0.005160578125, 0.005160578125, 0.010201 };\n double truth_three_index_tuples[27] = { 0.008890640625, 0.008890640625, 0.0039125,\n 0.004624203125, 0.004624203125, 0.0038125, 0.005215703125, 0.005215703125,\n 0.0045725, 0.004624203125, 0.004624203125, 0.0038125, 0.003737578125,\n 0.003737578125, 0.0040125, 0.004377078125, 0.004377078125, 0.0048525,\n 0.005215703125, 0.005215703125, 0.0045725, 0.004377078125, 0.004377078125,\n 0.0048525, 0.005160578125, 0.005160578125, 0.0058845 };\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n tsk_size_t sample_set_sizes[3], num_index_tuples;\n tsk_id_t sample_sets[ts.num_samples * 3], index_tuples[2 * 3] = { 0, 1, 0, 0, 0, 2 };\n tsk_size_t num_trees = ts.num_trees;\n double *positions = tsk_malloc(num_trees * sizeof(*positions));\n double positions_subset_1[2] = { 0., 0.1 };\n double positions_subset_2[2] = { 2., 6. };\n double positions_subset_3[2] = { 9., 9.999 };\n\n // First sample set contains all of the samples\n sample_set_sizes[0] = ts.num_samples;\n num_sample_sets = 1;\n for (i = 0; i < ts.num_samples; i++) {\n sample_sets[i] = (tsk_id_t) i;\n }\n for (i = 0; i < num_trees; i++) {\n positions[i] = ts.breakpoints[i];\n }\n\n options |= TSK_STAT_BRANCH;\n\n result_size = num_trees * num_trees * num_sample_sets;\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_trees,\n NULL, positions, num_trees, NULL, positions, options, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_one_set);\n\n // Second sample set contains all of the samples\n sample_set_sizes[1] = ts.num_samples;\n num_sample_sets = 2;\n for (i = ts.num_samples; i < ts.num_samples * 2; i++) {\n sample_sets[i] = (tsk_id_t) i - (tsk_id_t) ts.num_samples;\n }\n\n result_size = num_trees * num_trees * num_sample_sets;\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_trees,\n NULL, positions, num_trees, NULL, positions, options, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_two_sets);\n\n // Third sample set contains the first two samples\n sample_set_sizes[2] = 2;\n num_sample_sets = 3;\n for (i = ts.num_samples * 2; i < (ts.num_samples * 3) - 2; i++) {\n sample_sets[i] = (tsk_id_t) i - (tsk_id_t) ts.num_samples * 2;\n }\n\n result_size = num_trees * num_trees * num_sample_sets;\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_trees,\n NULL, positions, num_trees, NULL, positions, options, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal_nan(result_size, result, truth_three_sets);\n\n result_size = 4 * num_sample_sets;\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D2(&ts, num_sample_sets, sample_set_sizes, sample_sets, 2, NULL,\n positions_subset_1, 2, NULL, positions_subset_1, options, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal_nan(result_size, result, truth_positions_subset_1);\n\n result_size = 4 * num_sample_sets;\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D2(&ts, num_sample_sets, sample_set_sizes, sample_sets, 2, NULL,\n positions_subset_2, 2, NULL, positions_subset_2, options, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal_nan(result_size, result, truth_positions_subset_2);\n\n result_size = 4 * num_sample_sets;\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D2(&ts, num_sample_sets, sample_set_sizes, sample_sets, 2, NULL,\n positions_subset_3, 2, NULL, positions_subset_3, options, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal_nan(result_size, result, truth_positions_subset_3);\n\n // Two-way stats: we'll reuse all sample sets from the first 3 tests\n num_sample_sets = 3;\n result_size = num_trees * num_trees;\n\n num_index_tuples = 1;\n // We'll compute D2 between sample set 0 and sample set 1\n tsk_memset(result, 0, sizeof(*result) * result_size * num_index_tuples);\n ret = tsk_treeseq_D2_ij(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_index_tuples, index_tuples, num_trees, NULL, positions, num_trees, NULL,\n positions, options, result);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size * num_index_tuples, result, truth_one_set);\n\n // Compare sample sets [(0, 1), (0, 0)]\n num_index_tuples = 2;\n tsk_memset(result, 0, sizeof(*result) * result_size * num_index_tuples);\n ret = tsk_treeseq_D2_ij(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_index_tuples, index_tuples, num_trees, NULL, positions, num_trees, NULL,\n positions, options, result);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size * num_index_tuples, result, truth_two_sets);\n\n // Compare sample sets [(0, 1), (0, 0), (0, 2)]\n num_index_tuples = 3;\n tsk_memset(result, 0, sizeof(*result) * result_size * num_index_tuples);\n ret = tsk_treeseq_D2_ij(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_index_tuples, index_tuples, num_trees, NULL, positions, num_trees, NULL,\n positions, options, result);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal_nan(\n result_size * num_index_tuples, result, truth_three_index_tuples);\n\n tsk_treeseq_free(&ts);\n tsk_safe_free(positions);\n}\n\nstatic void\ntest_two_site_correlated_multiallelic(void)\n{\n const char *nodes = \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"0 2 -1\\n\"\n \"0 4 -1\\n\"\n \"0 6 -1\\n\"\n \"0 8 -1\\n\"\n \"0 10 -1\\n\"\n \"0 12 -1\\n\"\n \"0 14 -1\\n\"\n \"0 16 -1\\n\";\n const char *edges = \"0 20 9 0,1\\n\"\n \"0 20 10 2,9\\n\"\n \"0 20 11 4,5\\n\"\n \"0 20 12 6,11\\n\"\n \"0 20 13 7,8\\n\"\n \"0 20 14 3,10\\n\"\n \"0 10 15 12\\n\"\n \"10 20 15 13\\n\"\n \"0 10 15 14\\n\"\n \"10 20 15 14\\n\"\n \"10 20 16 12\\n\"\n \"0 10 16 13\\n\"\n \"0 10 16 15\\n\"\n \"10 20 16 15\\n\";\n const char *tree_sites = \"7 A\\n\"\n \"13 G\\n\";\n const char *mutations = \"0 15 T -1\\n\"\n \"0 14 G 0\\n\"\n \"1 15 T -1\\n\"\n \"1 13 C 2\\n\";\n\n int ret;\n\n tsk_treeseq_t ts;\n tsk_size_t s, result_size;\n\n double truth_D[4] = { 0.043209876543209874, -0.018518518518518517,\n -0.018518518518518517, 0.05555555555555555 };\n double truth_D2[4] = { 0.023844603634269844, 0.02384460363426984,\n 0.02384460363426984, 0.02384460363426984 };\n double truth_r2[4] = { 1, 1, 1, 1 };\n double truth_D_prime[4] = { 0, -0.5, -0.5, 0 };\n double truth_r[4] = { 0.18377223398316206, -0.12212786219416509,\n -0.12212786219416509, 0.2609542781331212 };\n double truth_Dz[4] = { 0.0033870175616860566, 0.003387017561686057,\n 0.003387017561686057, 0.003387017561686057 };\n double truth_pi2[4] = { 0.04579247743399549, 0.04579247743399549,\n 0.04579247743399549, 0.0457924774339955 };\n double truth_D2_unbiased[4] = { 0.026455026455026454, 0.026455026455026454,\n 0.026455026455026454, 0.026455026455026454 };\n double truth_Dz_unbiased[4] = { -0.008818342151675485, -0.008818342151675485,\n -0.008818342151675485, -0.008818342151675485 };\n double truth_pi2_unbiased[4] = { 0.0582010582010582, 0.0582010582010582,\n 0.0582010582010582, 0.0582010582010582 };\n double truth_D2_unbiased_disjoint[4] = { 0.007407407407407407, 0.007407407407407407,\n 0.007407407407407407, 0.007407407407407407 };\n\n tsk_treeseq_from_text(\n &ts, 20, nodes, edges, NULL, tree_sites, mutations, NULL, NULL, 0);\n\n tsk_size_t num_sample_sets = 1;\n tsk_size_t sample_set_sizes[2] = { ts.num_samples, ts.num_samples };\n tsk_id_t sample_sets[ts.num_samples * 2];\n tsk_size_t num_sites = ts.tables->sites.num_rows;\n tsk_id_t *sites = tsk_malloc(num_sites * sizeof(*sites));\n result_size = num_sites * num_sites;\n double result[result_size];\n\n // Two sample sets for multipop at the bottom, only presenting one to single pop\n // results\n for (s = 0; s < ts.num_samples; s++) {\n sample_sets[s] = (tsk_id_t) s;\n sample_sets[s + ts.num_samples] = (tsk_id_t) s;\n }\n for (s = 0; s < num_sites; s++) {\n sites[s] = (tsk_id_t) s;\n }\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_D(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_D2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D2);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_r2);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_D_prime(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_sites, sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D_prime);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_r(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_r);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_Dz(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_Dz);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_pi2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_pi2);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_D2_unbiased(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_sites, sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D2_unbiased);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_Dz_unbiased(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_sites, sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_Dz_unbiased);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_pi2_unbiased(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_sites, sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_pi2_unbiased);\n\n // We'll compute r2 between sample set 0 and sample set 1\n num_sample_sets = 2;\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_r2_ij(&ts, num_sample_sets, sample_set_sizes, sample_sets, 1,\n (tsk_id_t[2]) { 0, 0 }, num_sites, sites, NULL, num_sites, sites, NULL, 0,\n result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_r2);\n\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D2_ij(&ts, num_sample_sets, sample_set_sizes, sample_sets, 1,\n (tsk_id_t[2]) { 0, 0 }, num_sites, sites, NULL, num_sites, sites, NULL, 0,\n result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D2);\n\n // perfectly overlapping sample sets will produce a result equal to the single\n // population case\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D2_ij_unbiased(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n 1, (tsk_id_t[2]) { 0, 0 }, num_sites, sites, NULL, num_sites, sites, NULL, 0,\n result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D2_unbiased);\n\n // two disjoint sample sets with 5 and 4 samples {0,1,2,3,4}{5,6,7,8}\n sample_set_sizes[0] = 5;\n sample_set_sizes[1] = 4;\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D2_ij_unbiased(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n 1, (tsk_id_t[2]) { 0, 1 }, num_sites, sites, NULL, num_sites, sites, NULL, 0,\n result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D2_unbiased_disjoint);\n\n tsk_treeseq_free(&ts);\n tsk_safe_free(sites);\n}\n\nstatic void\ntest_two_site_uncorrelated_multiallelic(void)\n{\n const char *nodes = \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"0 2 -1\\n\"\n \"0 4 -1\\n\"\n \"0 6 -1\\n\"\n \"0 8 -1\\n\"\n \"0 10 -1\\n\"\n \"0 12 -1\\n\"\n \"0 14 -1\\n\"\n \"0 16 -1\\n\"\n \"0 2 -1\\n\"\n \"0 4 -1\\n\"\n \"0 6 -1\\n\"\n \"0 8 -1\\n\"\n \"0 10 -1\\n\"\n \"0 12 -1\\n\"\n \"0 14 -1\\n\"\n \"0 16 -1\\n\";\n const char *edges = \"0 10 9 0,1\\n\"\n \"10 20 17 0,3\\n\"\n \"0 10 10 2,9\\n\"\n \"10 20 18 6,17\\n\"\n \"0 10 11 3,4\\n\"\n \"10 20 19 1,4\\n\"\n \"0 10 12 5,11\\n\"\n \"10 20 20 7,19\\n\"\n \"0 10 13 6,7\\n\"\n \"10 20 21 2,5\\n\"\n \"0 10 14 8,13\\n\"\n \"10 20 22 8,21\\n\"\n \"0 10 15 10,12\\n\"\n \"10 20 23 18,20\\n\"\n \"0 10 16 14,15\\n\"\n \"10 20 24 22,23\\n\";\n const char *tree_sites = \"7 A\\n\"\n \"13 G\\n\";\n const char *mutations = \"0 15 T -1\\n\"\n \"0 12 G 0\\n\"\n \"1 23 T -1\\n\"\n \"1 20 A 2\\n\";\n\n tsk_treeseq_t ts;\n\n int ret;\n\n double truth_D[4] = { 0.05555555555555555, 0.0, 0.0, 0.05555555555555555 };\n double truth_D2[4] = { 0.024691358024691357, 0.0, 0.0, 0.024691358024691357 };\n double truth_r2[4] = { 1, 0, 0, 1 };\n double truth_D_prime[4] = { 0.0, 0.0, 0.0, 0.0 };\n double truth_r[4] = { 0.25, 0.0, 0.0, 0.25 };\n double truth_Dz[4] = { 0.0, 0.0, 0.0, 0.0 };\n double truth_pi2[4] = { 0.04938271604938272, 0.04938271604938272,\n 0.04938271604938272, 0.04938271604938272 };\n double truth_D2_unbiased[4] = { 0.027777777777777776, -0.009259259259259259,\n -0.009259259259259259, 0.027777777777777776 };\n double truth_Dz_unbiased[4] = { -0.015873015873015872, 0.005291005291005289,\n 0.005291005291005289, -0.015873015873015872 };\n double truth_pi2_unbiased[4] = { 0.06349206349206349, 0.06216931216931215,\n 0.06216931216931215, 0.06349206349206349 };\n double truth_D2_unbiased_disjoint[4] = { 0.008333333333333333,\n -0.0027777777777777775, -0.0027777777777777775, 0.03518518518518518 };\n\n tsk_treeseq_from_text(\n &ts, 20, nodes, edges, NULL, tree_sites, mutations, NULL, NULL, 0);\n\n tsk_size_t s;\n tsk_size_t num_sample_sets = 1;\n tsk_size_t num_sites = ts.tables->sites.num_rows;\n tsk_id_t *sites = tsk_malloc(num_sites * sizeof(*sites));\n tsk_size_t sample_set_sizes[2] = { ts.num_samples, ts.num_samples };\n tsk_id_t sample_sets[ts.num_samples * 2];\n tsk_size_t result_size = num_sites * num_sites;\n double result[result_size];\n\n // Two sample sets for multipop at the bottom, only presenting one to single pop\n // results\n for (s = 0; s < ts.num_samples; s++) {\n sample_sets[s] = (tsk_id_t) s;\n sample_sets[s + ts.num_samples] = (tsk_id_t) s;\n }\n for (s = 0; s < num_sites; s++) {\n sites[s] = (tsk_id_t) s;\n }\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_D(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_D2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D2);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_r2);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_D_prime(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_sites, sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D_prime);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_r(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_r);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_Dz(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_Dz);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_pi2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_pi2);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_D2_unbiased(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_sites, sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D2_unbiased);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_Dz_unbiased(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_sites, sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_Dz_unbiased);\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_pi2_unbiased(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_sites, sites, NULL, num_sites, sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_pi2_unbiased);\n\n // We'll compute r2 between sample set 0 and sample set 1\n num_sample_sets = 2;\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_r2_ij(&ts, num_sample_sets, sample_set_sizes, sample_sets, 1,\n (tsk_id_t[2]) { 0, 0 }, num_sites, sites, NULL, num_sites, sites, NULL, 0,\n result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_r2);\n\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D2_ij(&ts, num_sample_sets, sample_set_sizes, sample_sets, 1,\n (tsk_id_t[2]) { 0, 0 }, num_sites, sites, NULL, num_sites, sites, NULL, 0,\n result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D2);\n\n // perfectly overlapping sample sets will produce a result equal to the single\n // population case\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D2_ij_unbiased(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n 1, (tsk_id_t[2]) { 0, 0 }, num_sites, sites, NULL, num_sites, sites, NULL, 0,\n result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D2_unbiased);\n\n // two disjoint sample sets with 5 and 4 samples {0,1,2,3,4}{5,6,7,8}\n sample_set_sizes[0] = 5;\n sample_set_sizes[1] = 4;\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D2_ij_unbiased(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n 1, (tsk_id_t[2]) { 0, 1 }, num_sites, sites, NULL, num_sites, sites, NULL, 0,\n result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D2_unbiased_disjoint);\n\n tsk_treeseq_free(&ts);\n tsk_safe_free(sites);\n}\n\nstatic void\ntest_two_site_backmutation(void)\n{\n const char *nodes\n = \"1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n\"\n \"1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n\"\n \"1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n\"\n \"1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n\"\n \"1 0 -1\\n1 0 -1\\n1 0 -1\\n0 2 -1\\n0 4 -1\\n0 6 -1\\n0 8 -1\\n0 10 -1\\n\"\n \"0 12 -1\\n0 14 -1\\n0 16 -1\\n0 18 -1\\n0 20 -1\\n0 22 -1\\n0 24 -1\\n0 26 -1\\n\"\n \"0 28 -1\\n0 30 -1\\n0 32 -1\\n0 34 -1\\n0 36 -1\\n0 38 -1\\n0 40 -1\\n0 42 -1\\n\"\n \"0 44 -1\\n0 46 -1\\n0 48 -1\\n0 50 -1\\n0 52 -1\\n0 54 -1\\n0 56 -1\\n0 58 -1\\n\"\n \"0 60 -1\\n0 62 -1\\n0 64 -1\\n0 66 -1\\n0 68 -1\\n\";\n\n const char *edges\n = \"0 10 35 0,1\\n0 10 36 2,35\\n0 10 37 3,36\\n0 10 38 4,37\\n0 10 39 5,38\\n\"\n \"0 10 40 6,39\\n0 10 41 7,40\\n0 10 42 8,41\\n0 10 43 9,42\\n0 10 44 10,43\\n\"\n \"0 10 45 11,44\\n0 10 46 12,45\\n0 10 47 13,46\\n0 10 48 14,47\\n0 10 49 15,48\\n\"\n \"0 10 50 16,49\\n0 10 51 17,50\\n0 10 52 18,51\\n0 10 53 19,52\\n0 10 54 20,53\\n\"\n \"0 10 55 21,54\\n0 10 56 22,55\\n0 10 57 23,56\\n0 10 58 24,57\\n0 10 59 25,58\\n\"\n \"0 10 60 26,59\\n0 10 61 27,60\\n0 10 62 28,61\\n0 10 63 29,62\\n0 10 64 30,63\\n\"\n \"0 10 65 31,64\\n0 10 66 32,65\\n0 10 67 33,66\\n0 10 68 34,67\\n\";\n\n const char *sites = \"1 A\\n\"\n \"4.5 T\\n\";\n\n const char *mutations = \"0 50 T -1\\n\"\n \"0 48 G 0\\n\"\n \"0 46 A 1\\n\"\n \"1 62 G -1\\n\"\n \"1 60 T 3\\n\"\n \"1 58 A 4\\n\";\n\n int ret;\n\n tsk_treeseq_t ts;\n tsk_treeseq_from_text(&ts, 10, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n\n tsk_size_t num_sample_sets = 1;\n tsk_size_t num_sites = ts.tables->sites.num_rows;\n tsk_id_t *row_sites = tsk_malloc(num_sites * sizeof(*row_sites));\n tsk_id_t *col_sites = tsk_malloc(num_sites * sizeof(*col_sites));\n tsk_size_t sample_set_sizes[1] = { ts.num_samples };\n tsk_id_t sample_sets[ts.num_samples];\n tsk_size_t result_size = num_sites * num_sites;\n double result[result_size];\n tsk_size_t s;\n\n double truth_r2[4] = { 0.999999999999999, 0.042923862278701, 0.042923862278701, 1. };\n\n for (s = 0; s < ts.num_samples; s++) {\n sample_sets[s] = (tsk_id_t) s;\n }\n for (s = 0; s < num_sites; s++) {\n row_sites[s] = (tsk_id_t) s;\n col_sites[s] = (tsk_id_t) s;\n }\n\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n row_sites, NULL, num_sites, col_sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_r2);\n\n tsk_treeseq_free(&ts);\n tsk_safe_free(row_sites);\n tsk_safe_free(col_sites);\n}\n\nstatic void\ntest_two_locus_branch_all_stats(void)\n{\n int ret;\n tsk_treeseq_t ts;\n double result[16];\n tsk_size_t result_size = 16;\n tsk_id_t sample_sets[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };\n tsk_size_t sample_set_sizes[1] = { 10 };\n double positions[4] = { 0.0, 2.0, 5.0, 6.0 };\n\n const char *nodes\n = \"1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n1 0 -1\\n\"\n \"1 0 -1\\n1 0 -1\\n0 0.02 -1\\n0 0.06 -1\\n0 0.08 -1\\n0 0.09 -1\\n0 0.21 -1\\n\"\n \"0 0.35 -1\\n0 0.44 -1\\n0 0.69 -1\\n0 0.79 -1\\n0 0.80 -1\\n0 0.84 -1\\n\"\n \"0 1.26 -1\\n\";\n const char *edges\n = \"0 10 10 0,8\\n0 10 11 4,7\\n0 10 12 3,9\\n0 10 13 6,11\\n0 10 14 1,2\\n\"\n \"5 10 15 5,10\\n0 5 16 5,10\\n6 10 17 12,14\\n2 6 18 14\\n5 10 18 15\\n\"\n \"2 5 18 16\\n6 10 18 17\\n0 6 19 12\\n0 2 19 14\\n2 6 19 18\\n\"\n \"0 2 20 13\\n0 2 20 16\\n2 10 21 13\\n6 10 21 18\\n0 6 21 19\\n\"\n \"0 2 21 20\\n\";\n\n double truth_D[16] = { 0 };\n double truth_D2[16] = { 0.21949755999999998, 0.1867003599999999, 0.18798699999999988,\n 0.18941379999999983, 0.18670035999999995, 0.21159555999999993,\n 0.21257979999999996, 0.21222580000000005, 0.187987, 0.21257979999999996,\n 0.21380379999999996, 0.2134714, 0.18941379999999994, 0.21222579999999996,\n 0.21347139999999992, 0.21377299999999996 };\n double truth_r2[16] = { 6.286870108969513, 5.742220038107836, 5.7080225607835695,\n 5.623290389581752, 5.742220038107832, 6.3274209876543175, 6.291288603867465,\n 6.195658345930953, 5.708022560783573, 6.291288603867472, 6.266256220080618,\n 6.170677280171318, 5.623290389581758, 6.195658345930966, 6.170677280171324,\n 6.094109054547737 };\n double truth_D_prime[16] = { -9.6552, -9.44459999999999, -9.136799999999988,\n -8.680999999999989, -9.444599999999998, -9.240699999999984, -8.937399999999977,\n -8.488499999999984, -9.136799999999996, -8.93739999999999, -8.658399999999984,\n -8.219399999999993, -8.68099999999999, -8.488499999999991, -8.21939999999999,\n -7.814699999999995 };\n double truth_r[16] = { 0.023193673439522472, 0.023272634599981495,\n 0.021243465874728862, 0.01919099466703808, 0.023272634599981454,\n 0.023358527073393587, 0.021370047752011, 0.019268461077492888,\n 0.021243465874728862, 0.021370047752011012, 0.020359977803327087,\n 0.01793842604857987, 0.019190994667037817, 0.019268461077492804,\n 0.017938426048579773, 0.0160605735196305 };\n double truth_Dz[16] = { 0.01958895999999996, -0.007941440000000037,\n -0.007572800000000046, -0.010558400000000029, -0.007941440000000022,\n 0.01385535999999997, 0.014569599999999966, 0.015529599999999963,\n -0.007572800000000024, 0.01456959999999996, 0.015426399999999951,\n 0.016271199999999948, -0.010558400000000011, 0.01552959999999999,\n 0.016271199999999986, 0.017607999999999985 };\n double truth_pi2[16] = { 0.7201219600000001, 0.6895723600000001, 0.6865174000000006,\n 0.6780314000000008, 0.6895723600000002, 0.6603187600000002, 0.6573934000000002,\n 0.6492674000000002, 0.6865174000000002, 0.6573934000000003, 0.6544810000000003,\n 0.6463910000000003, 0.6780314000000002, 0.6492674000000004, 0.6463910000000005,\n 0.6384010000000007 };\n double truth_Dz_unbiased[16] = { -0.06387380952380949, -0.09312571428571428,\n -0.09361428571428566, -0.10075682539682536, -0.09312571428571428,\n -0.0734419047619048, -0.0730733333333334, -0.07171301587301597,\n -0.0936142857142857, -0.07307333333333343, -0.07261476190476202,\n -0.07147730158730167, -0.10075682539682543, -0.07171301587301596,\n -0.07147730158730159, -0.06988666666666674 };\n double truth_D2_unbiased[16] = { 0.19576484126984134, 0.1586769841269842,\n 0.16093412698412704, 0.16485253968253985, 0.15867698412698414,\n 0.1949926984126984, 0.19673555555555555, 0.19734825396825403,\n 0.16093412698412699, 0.1967355555555555, 0.19879341269841264,\n 0.19945182539682532, 0.16485253968253968, 0.19734825396825395,\n 0.1994518253968253, 0.20091222222222213 };\n double truth_pi2_unbiased[16] = { 0.8910765079365083, 0.8571103174603181,\n 0.853337460317461, 0.8434880952380959, 0.8571103174603178, 0.8182193650793657,\n 0.8145322222222225, 0.8043504761904768, 0.8533374603174609, 0.8145322222222225,\n 0.8108450793650795, 0.800729047619048, 0.8434880952380955, 0.8043504761904766,\n 0.8007290476190477, 0.7906733333333332 };\n\n tsk_treeseq_from_text(&ts, 10, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D(&ts, 1, sample_set_sizes, sample_sets, 4, NULL, positions, 4,\n NULL, positions, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D);\n\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D2(&ts, 1, sample_set_sizes, sample_sets, 4, NULL, positions, 4,\n NULL, positions, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D2);\n\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_r2(&ts, 1, sample_set_sizes, sample_sets, 4, NULL, positions, 4,\n NULL, positions, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_r2);\n\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D_prime(&ts, 1, sample_set_sizes, sample_sets, 4, NULL, positions,\n 4, NULL, positions, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D_prime);\n\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_r(&ts, 1, sample_set_sizes, sample_sets, 4, NULL, positions, 4,\n NULL, positions, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_r);\n\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_Dz(&ts, 1, sample_set_sizes, sample_sets, 4, NULL, positions, 4,\n NULL, positions, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_Dz);\n\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_pi2(&ts, 1, sample_set_sizes, sample_sets, 4, NULL, positions, 4,\n NULL, positions, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_pi2);\n\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_Dz_unbiased(&ts, 1, sample_set_sizes, sample_sets, 4, NULL,\n positions, 4, NULL, positions, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_Dz_unbiased);\n\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_D2_unbiased(&ts, 1, sample_set_sizes, sample_sets, 4, NULL,\n positions, 4, NULL, positions, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_D2_unbiased);\n\n tsk_memset(result, 0, sizeof(*result) * result_size);\n ret = tsk_treeseq_pi2_unbiased(&ts, 1, sample_set_sizes, sample_sets, 4, NULL,\n positions, 4, NULL, positions, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size, result, truth_pi2_unbiased);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_paper_ex_two_site_subset(void)\n{\n tsk_treeseq_t ts;\n double result[4];\n int ret;\n tsk_size_t s, result_size;\n tsk_size_t sample_set_sizes[1];\n tsk_size_t num_sample_sets;\n tsk_id_t row_sites[2] = { 0, 1 };\n tsk_id_t col_sites[2] = { 1, 2 };\n double result_truth_1[4] = { 0.1111111111111111, 0.1111111111111111, 1, 1 };\n double result_truth_2[1] = { 0.1111111111111111 };\n double result_truth_3[4] = { 0.1111111111111111, 1, 0.1111111111111111, 1 };\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n tsk_id_t sample_sets[ts.num_samples];\n\n sample_set_sizes[0] = ts.num_samples;\n num_sample_sets = 1;\n for (s = 0; s < ts.num_samples; s++) {\n sample_sets[s] = (tsk_id_t) s;\n }\n\n result_size = 2 * 2;\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, 2,\n row_sites, NULL, 2, col_sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size * num_sample_sets, result, result_truth_1);\n\n result_size = 1 * 1;\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n col_sites[0] = 2;\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, 1,\n row_sites, NULL, 1, col_sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size * num_sample_sets, result, result_truth_2);\n\n result_size = 2 * 2;\n tsk_memset(result, 0, sizeof(*result) * result_size * num_sample_sets);\n row_sites[0] = 1;\n row_sites[1] = 2;\n col_sites[0] = 0;\n col_sites[1] = 1;\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, 2,\n row_sites, NULL, 2, col_sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(result_size * num_sample_sets, result, result_truth_3);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_two_locus_stat_input_errors(void)\n{\n tsk_treeseq_t ts;\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n\n tsk_size_t num_sites = ts.tables->sites.num_rows;\n tsk_id_t *row_sites = tsk_malloc(num_sites * sizeof(*row_sites));\n tsk_id_t *col_sites = tsk_malloc(num_sites * sizeof(*col_sites));\n tsk_size_t sample_set_sizes[2] = { ts.num_samples, ts.num_samples };\n tsk_size_t num_sample_sets = 1;\n tsk_id_t index_tuples[2] = { 0 };\n tsk_size_t num_index_tuples = 1;\n tsk_id_t sample_sets[ts.num_samples * 2]; // need 2 sample sets for multipop\n double positions[10] = { 0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 };\n double bad_col_positions[2] = { 0., 0. }; // used in 1 test to cover column check\n double result[100];\n tsk_size_t s;\n\n for (s = 0; s < ts.num_samples; s++) {\n sample_sets[s] = (tsk_id_t) s;\n sample_sets[s + ts.num_samples] = (tsk_id_t) s;\n }\n for (s = 0; s < num_sites; s++) {\n row_sites[s] = (tsk_id_t) s;\n col_sites[s] = (tsk_id_t) s;\n }\n // begin with the happy path\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n row_sites, NULL, num_sites, col_sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_two_locus_count_stat(&ts, num_sample_sets, sample_set_sizes,\n sample_sets, 0, NULL, NULL, NULL, num_sites, row_sites, NULL, num_sites,\n col_sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_RESULT_DIMS);\n\n ret = tsk_treeseq_r2(&ts, 1, sample_set_sizes, sample_sets, num_sites, row_sites,\n NULL, num_sites, col_sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n sample_sets[1] = 0;\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n row_sites, NULL, num_sites, col_sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n sample_sets[1] = 1;\n\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n row_sites, NULL, num_sites, col_sites, NULL, TSK_STAT_SITE | TSK_STAT_BRANCH,\n result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MULTIPLE_STAT_MODES);\n\n ret = tsk_treeseq_r2(&ts, 0, sample_set_sizes, sample_sets, num_sites, row_sites,\n NULL, num_sites, col_sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INSUFFICIENT_SAMPLE_SETS);\n\n sample_set_sizes[0] = 0;\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n row_sites, NULL, num_sites, col_sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EMPTY_SAMPLE_SET);\n sample_set_sizes[0] = ts.num_samples;\n\n sample_sets[1] = 10;\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n row_sites, NULL, num_sites, col_sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n sample_sets[1] = 1;\n\n row_sites[0] = 1000;\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n row_sites, NULL, num_sites, col_sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n row_sites[0] = 0;\n\n col_sites[num_sites - 1] = (tsk_id_t) num_sites;\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n row_sites, NULL, num_sites, col_sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n col_sites[num_sites - 1] = (tsk_id_t) num_sites - 1;\n\n row_sites[0] = 1;\n row_sites[1] = 0;\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n row_sites, NULL, num_sites, col_sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_STAT_UNSORTED_SITES);\n row_sites[0] = 0;\n row_sites[1] = 1;\n\n row_sites[0] = 1;\n row_sites[1] = 1;\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, num_sites,\n row_sites, NULL, num_sites, col_sites, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_STAT_DUPLICATE_SITES);\n row_sites[0] = 0;\n row_sites[1] = 1;\n\n // Not an error condition, but we want to record this behavior. The method is robust\n // to zero-length site/position inputs.\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, 0, NULL,\n NULL, 0, NULL, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, 0, NULL,\n NULL, 0, NULL, NULL, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n positions[9] = 1;\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, 10, NULL,\n positions, 10, NULL, positions, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POSITION_OUT_OF_BOUNDS);\n positions[9] = 0.9;\n\n positions[0] = -0.1;\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, 10, NULL,\n positions, 10, NULL, positions, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POSITION_OUT_OF_BOUNDS);\n positions[0] = 0;\n\n positions[0] = 0.1;\n positions[1] = 0;\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, 10, NULL,\n positions, 10, NULL, positions, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_STAT_UNSORTED_POSITIONS);\n positions[0] = 0;\n positions[1] = 0.1;\n\n // rows always fail first, check columns\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, 10, NULL,\n positions, 2, NULL, bad_col_positions, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_STAT_DUPLICATE_POSITIONS);\n\n positions[0] = 0;\n positions[1] = 0;\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, 10, NULL,\n positions, 10, NULL, positions, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_STAT_DUPLICATE_POSITIONS);\n positions[0] = 0;\n positions[1] = 0.1;\n\n ret = tsk_treeseq_r2(&ts, num_sample_sets, sample_set_sizes, sample_sets, 10, NULL,\n positions, 10, NULL, positions, TSK_STAT_NODE, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSUPPORTED_STAT_MODE);\n\n num_sample_sets = 2;\n num_index_tuples = 0;\n ret = tsk_treeseq_r2_ij(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_index_tuples, index_tuples, num_sites, row_sites, NULL, num_sites, col_sites,\n NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INSUFFICIENT_INDEX_TUPLES);\n\n num_sample_sets = 0;\n num_index_tuples = 1;\n ret = tsk_treeseq_D2_ij(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_index_tuples, index_tuples, num_sites, row_sites, NULL, num_sites, col_sites,\n NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INSUFFICIENT_SAMPLE_SETS);\n\n num_sample_sets = 2;\n index_tuples[0] = 2;\n ret = tsk_treeseq_D2_ij_unbiased(&ts, num_sample_sets, sample_set_sizes, sample_sets,\n num_index_tuples, index_tuples, num_sites, row_sites, NULL, num_sites, col_sites,\n NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SAMPLE_SET_INDEX);\n\n tsk_treeseq_free(&ts);\n tsk_safe_free(row_sites);\n tsk_safe_free(col_sites);\n}\n\nstatic void\ntest_simplest_divergence_matrix(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\";\n const char *edges = \"0 1 2 0,1\\n\";\n const char *sites = \"0.1 A\\n\"\n \"0.6 A\\n\";\n const char *mutations = \"0 0 B -1\\n\"\n \"1 0 B -1\\n\";\n tsk_treeseq_t ts;\n tsk_id_t sample_ids[] = { 0, 1 };\n double D_branch[4] = { 0, 2, 2, 0 };\n double D_site[4] = { 0, 2, 2, 0 };\n double result[4];\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 2, NULL, sample_ids, 0, NULL, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(4, D_branch, result);\n\n ret = tsk_treeseq_divergence_matrix(&ts, 2, NULL, sample_ids, 0, NULL,\n TSK_STAT_BRANCH | TSK_STAT_SPAN_NORMALISE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(4, D_branch, result);\n\n ret = tsk_treeseq_divergence_matrix(&ts, 2, NULL, sample_ids, 0, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(4, D_site, result);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 2, NULL, sample_ids, 0, NULL, TSK_STAT_SPAN_NORMALISE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(4, D_site, result);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 2, NULL, sample_ids, 0, NULL, TSK_STAT_SITE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(4, D_site, result);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 0, NULL, NULL, 0, NULL, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(4, D_branch, result);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 0, NULL, NULL, 0, NULL, TSK_STAT_SITE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(4, D_site, result);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 0, NULL, NULL, 0, NULL, TSK_STAT_NODE, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSUPPORTED_STAT_MODE);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 0, NULL, NULL, 0, NULL, TSK_STAT_POLARISED, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_STAT_POLARISED_UNSUPPORTED);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 0, NULL, NULL, 0, NULL, TSK_STAT_SITE | TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MULTIPLE_STAT_MODES);\n\n sample_ids[0] = -1;\n ret = tsk_treeseq_divergence_matrix(&ts, 2, NULL, sample_ids, 0, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n sample_ids[0] = 3;\n ret = tsk_treeseq_divergence_matrix(&ts, 2, NULL, sample_ids, 0, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n sample_ids[0] = 1;\n ret = tsk_treeseq_divergence_matrix(&ts, 2, NULL, sample_ids, 0, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n ret = tsk_treeseq_divergence_matrix(\n &ts, 2, NULL, sample_ids, 0, NULL, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n\n sample_ids[0] = 2;\n ret = tsk_treeseq_divergence_matrix(&ts, 2, NULL, sample_ids, 0, NULL, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SAMPLES);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_divergence_matrix_windows(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\";\n const char *edges = \"0 1 2 0,1\\n\";\n const char *sites = \"0.1 A\\n\"\n \"0.6 A\\n\";\n const char *mutations = \"0 0 B -1\\n\"\n \"1 0 B -1\\n\";\n tsk_treeseq_t ts;\n tsk_id_t sample_ids[] = { 0, 1 };\n double D_branch[8] = { 0, 1, 1, 0, 0, 1, 1, 0 };\n double D_site[8] = { 0, 1, 1, 0, 0, 1, 1, 0 };\n double result[8];\n double windows[] = { 0, 0.5, 1 };\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n\n ret = tsk_treeseq_divergence_matrix(&ts, 2, NULL, sample_ids, 2, windows, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(8, D_site, result);\n ret = tsk_treeseq_divergence_matrix(\n &ts, 2, NULL, sample_ids, 2, windows, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(8, D_branch, result);\n\n /* Windows for the second half */\n ret = tsk_treeseq_divergence_matrix(\n &ts, 2, NULL, sample_ids, 1, windows + 1, TSK_STAT_SITE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(4, D_site, result);\n ret = tsk_treeseq_divergence_matrix(\n &ts, 2, NULL, sample_ids, 1, windows + 1, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(4, D_branch, result);\n\n ret = tsk_treeseq_divergence_matrix(&ts, 2, NULL, sample_ids, 0, windows, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_NUM_WINDOWS);\n\n windows[0] = -1;\n ret = tsk_treeseq_divergence_matrix(&ts, 2, NULL, sample_ids, 2, windows, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n windows[0] = 0.45;\n windows[2] = 1.5;\n ret = tsk_treeseq_divergence_matrix(&ts, 2, NULL, sample_ids, 2, windows, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n windows[0] = 0.55;\n windows[2] = 1.0;\n ret = tsk_treeseq_divergence_matrix(&ts, 2, NULL, sample_ids, 2, windows, 0, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_WINDOWS);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_divergence_matrix_internal_sample(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 1 0\\n\";\n const char *edges = \"0 1 2 0,1\\n\";\n tsk_treeseq_t ts;\n tsk_id_t sample_ids[] = { 0, 1, 2 };\n double result[9];\n double D_branch[9] = { 0, 2, 1, 2, 0, 1, 1, 1, 0 };\n double D_site[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 3, NULL, sample_ids, 0, NULL, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(9, D_branch, result);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts, 3, NULL, sample_ids, 0, NULL, TSK_STAT_SITE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_arrays_almost_equal(9, D_site, result);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_multiroot_divergence_matrix(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, multiroot_ex_nodes, multiroot_ex_edges, NULL,\n multiroot_ex_sites, multiroot_ex_mutations, NULL, NULL, 0);\n\n verify_divergence_matrix(&ts, TSK_STAT_BRANCH);\n verify_divergence_matrix(&ts, TSK_STAT_BRANCH | TSK_STAT_SPAN_NORMALISE);\n verify_divergence_matrix(&ts, TSK_STAT_SITE);\n verify_divergence_matrix(&ts, TSK_STAT_SITE | TSK_STAT_SPAN_NORMALISE);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_pair_coalescence_counts(void)\n{\n tsk_treeseq_t ts;\n tsk_treeseq_from_text(&ts, 100, nonbinary_ex_nodes, nonbinary_ex_edges, NULL,\n nonbinary_ex_sites, nonbinary_ex_mutations, NULL, NULL, 0);\n verify_pair_coalescence_counts(&ts, 0);\n verify_pair_coalescence_counts(&ts, TSK_STAT_SPAN_NORMALISE);\n verify_pair_coalescence_counts(&ts, TSK_STAT_PAIR_NORMALISE);\n verify_pair_coalescence_counts(\n &ts, TSK_STAT_SPAN_NORMALISE | TSK_STAT_PAIR_NORMALISE);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_pair_coalescence_counts_missing(void)\n{\n tsk_treeseq_t ts;\n tsk_treeseq_from_text(\n &ts, 5, missing_ex_nodes, missing_ex_edges, NULL, NULL, NULL, NULL, NULL, 0);\n verify_pair_coalescence_counts(&ts, 0);\n verify_pair_coalescence_counts(&ts, TSK_STAT_SPAN_NORMALISE);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_pair_coalescence_quantiles(void)\n{\n tsk_treeseq_t ts;\n tsk_treeseq_from_text(&ts, 100, nonbinary_ex_nodes, nonbinary_ex_edges, NULL,\n nonbinary_ex_sites, nonbinary_ex_mutations, NULL, NULL, 0);\n verify_pair_coalescence_quantiles(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_pair_coalescence_rates(void)\n{\n tsk_treeseq_t ts;\n tsk_treeseq_from_text(&ts, 100, nonbinary_ex_nodes, nonbinary_ex_edges, NULL,\n nonbinary_ex_sites, nonbinary_ex_mutations, NULL, NULL, 0);\n verify_pair_coalescence_rates(&ts);\n tsk_treeseq_free(&ts);\n}\n\nint\nmain(int argc, char **argv)\n{\n CU_TestInfo tests[] = {\n { \"test_general_stat_input_errors\", test_general_stat_input_errors },\n\n { \"test_empty_ts_ld\", test_empty_ts_ld },\n { \"test_empty_ts_mean_descendants\", test_empty_ts_mean_descendants },\n { \"test_empty_ts_genealogical_nearest_neighbours\",\n test_empty_ts_genealogical_nearest_neighbours },\n { \"test_empty_ts_general_stat\", test_empty_ts_general_stat },\n { \"test_empty_ts_afs\", test_empty_ts_afs },\n\n { \"test_single_tree_ld\", test_single_tree_ld },\n { \"test_single_tree_mean_descendants\", test_single_tree_mean_descendants },\n { \"test_single_tree_genealogical_nearest_neighbours\",\n test_single_tree_genealogical_nearest_neighbours },\n { \"test_single_tree_general_stat\", test_single_tree_general_stat },\n { \"test_single_tree_general_stat_errors\", test_single_tree_general_stat_errors },\n { \"test_single_tree_divergence_matrix\", test_single_tree_divergence_matrix },\n { \"test_single_tree_divergence_matrix_internal_samples\",\n test_single_tree_divergence_matrix_internal_samples },\n { \"test_single_tree_divergence_matrix_multi_root\",\n test_single_tree_divergence_matrix_multi_root },\n\n { \"test_paper_ex_ld\", test_paper_ex_ld },\n { \"test_paper_ex_mean_descendants\", test_paper_ex_mean_descendants },\n { \"test_paper_ex_genealogical_nearest_neighbours\",\n test_paper_ex_genealogical_nearest_neighbours },\n { \"test_paper_ex_general_stat_errors\", test_paper_ex_general_stat_errors },\n { \"test_paper_ex_general_stat\", test_paper_ex_general_stat },\n { \"test_paper_ex_trait_covariance_errors\",\n test_paper_ex_trait_covariance_errors },\n { \"test_paper_ex_trait_covariance\", test_paper_ex_trait_covariance },\n { \"test_paper_ex_trait_correlation_errors\",\n test_paper_ex_trait_correlation_errors },\n { \"test_paper_ex_trait_correlation\", test_paper_ex_trait_correlation },\n { \"test_paper_ex_trait_linear_model_errors\",\n test_paper_ex_trait_linear_model_errors },\n { \"test_paper_ex_trait_linear_model\", test_paper_ex_trait_linear_model },\n { \"test_paper_ex_diversity_errors\", test_paper_ex_diversity_errors },\n { \"test_paper_ex_diversity\", test_paper_ex_diversity },\n { \"test_paper_ex_segregating_sites_errors\",\n test_paper_ex_segregating_sites_errors },\n { \"test_paper_ex_segregating_sites\", test_paper_ex_segregating_sites },\n { \"test_paper_ex_Y1_errors\", test_paper_ex_Y1_errors },\n { \"test_paper_ex_Y1\", test_paper_ex_Y1 },\n { \"test_paper_ex_divergence_errors\", test_paper_ex_divergence_errors },\n { \"test_paper_ex_divergence\", test_paper_ex_divergence },\n { \"test_paper_ex_genetic_relatedness_errors\",\n test_paper_ex_genetic_relatedness_errors },\n { \"test_paper_ex_genetic_relatedness\", test_paper_ex_genetic_relatedness },\n { \"test_paper_ex_genetic_relatedness_weighted\",\n test_paper_ex_genetic_relatedness_weighted },\n { \"test_paper_ex_genetic_relatedness_weighted_errors\",\n test_paper_ex_genetic_relatedness_weighted_errors },\n { \"test_empty_genetic_relatedness_vector\",\n test_empty_genetic_relatedness_vector },\n { \"test_paper_ex_genetic_relatedness_vector\",\n test_paper_ex_genetic_relatedness_vector },\n { \"test_paper_ex_genetic_relatedness_vector_errors\",\n test_paper_ex_genetic_relatedness_vector_errors },\n { \"test_paper_ex_genetic_relatedness_vector_node_errors\",\n test_paper_ex_genetic_relatedness_vector_node_errors },\n { \"test_paper_ex_Y2_errors\", test_paper_ex_Y2_errors },\n { \"test_paper_ex_Y2\", test_paper_ex_Y2 },\n { \"test_paper_ex_f2_errors\", test_paper_ex_f2_errors },\n { \"test_paper_ex_f2\", test_paper_ex_f2 },\n { \"test_paper_ex_Y3_errors\", test_paper_ex_Y3_errors },\n { \"test_paper_ex_Y3\", test_paper_ex_Y3 },\n { \"test_paper_ex_f3_errors\", test_paper_ex_f3_errors },\n { \"test_paper_ex_f3\", test_paper_ex_f3 },\n { \"test_paper_ex_f4_errors\", test_paper_ex_f4_errors },\n { \"test_paper_ex_f4\", test_paper_ex_f4 },\n { \"test_paper_ex_afs_errors\", test_paper_ex_afs_errors },\n { \"test_paper_ex_afs\", test_paper_ex_afs },\n { \"test_paper_ex_divergence_matrix\", test_paper_ex_divergence_matrix },\n\n { \"test_unary_ex_afs\", test_unary_ex_afs },\n { \"test_nonbinary_ex_ld\", test_nonbinary_ex_ld },\n { \"test_nonbinary_ex_mean_descendants\", test_nonbinary_ex_mean_descendants },\n { \"test_nonbinary_ex_genealogical_nearest_neighbours\",\n test_nonbinary_ex_genealogical_nearest_neighbours },\n { \"test_nonbinary_ex_general_stat\", test_nonbinary_ex_general_stat },\n { \"test_nonbinary_ex_general_stat_errors\",\n test_nonbinary_ex_general_stat_errors },\n\n { \"test_caterpillar_tree_ld\", test_caterpillar_tree_ld },\n { \"test_ld_multi_mutations\", test_ld_multi_mutations },\n { \"test_ld_silent_mutations\", test_ld_silent_mutations },\n\n { \"test_paper_ex_two_site\", test_paper_ex_two_site },\n { \"test_paper_ex_two_branch\", test_paper_ex_two_branch },\n { \"test_two_site_correlated_multiallelic\",\n test_two_site_correlated_multiallelic },\n { \"test_two_site_uncorrelated_multiallelic\",\n test_two_site_uncorrelated_multiallelic },\n { \"test_two_site_backmutation\", test_two_site_backmutation },\n { \"test_two_locus_site_all_stats\", test_two_locus_branch_all_stats },\n { \"test_paper_ex_two_site_subset\", test_paper_ex_two_site_subset },\n { \"test_two_locus_stat_input_errors\", test_two_locus_stat_input_errors },\n\n { \"test_simplest_divergence_matrix\", test_simplest_divergence_matrix },\n { \"test_simplest_divergence_matrix_windows\",\n test_simplest_divergence_matrix_windows },\n { \"test_simplest_divergence_matrix_internal_sample\",\n test_simplest_divergence_matrix_internal_sample },\n { \"test_multiroot_divergence_matrix\", test_multiroot_divergence_matrix },\n\n { \"test_pair_coalescence_counts\", test_pair_coalescence_counts },\n { \"test_pair_coalescence_counts_missing\", test_pair_coalescence_counts_missing },\n { \"test_pair_coalescence_quantiles\", test_pair_coalescence_quantiles },\n { \"test_pair_coalescence_rates\", test_pair_coalescence_rates },\n\n { NULL, NULL },\n };\n return test_main(tests, argc, argv);\n}\n"
},
{
"path": "c/tests/test_tables.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2023 Tskit Developers\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \"testlib.h\"\n#include \"tskit/core.h\"\n#include \n\n#include \n#include \n#include \n\nstatic void\nreverse_migrations(tsk_table_collection_t *tables)\n{\n int ret;\n tsk_migration_table_t migrations;\n tsk_migration_t migration;\n tsk_id_t j, ret_id;\n\n /* Easy way to copy the metadata schema */\n ret = tsk_migration_table_copy(&tables->migrations, &migrations, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_migration_table_clear(&migrations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = (tsk_id_t) tables->migrations.num_rows - 1; j >= 0; j--) {\n ret = tsk_migration_table_get_row(&tables->migrations, j, &migration);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_migration_table_add_row(&migrations, migration.left,\n migration.right, migration.node, migration.source, migration.dest,\n migration.time, migration.metadata, migration.metadata_length);\n CU_ASSERT_FATAL(ret_id >= 0);\n }\n\n ret = tsk_migration_table_copy(&migrations, &tables->migrations, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_migration_table_free(&migrations);\n}\n\nstatic void\nreverse_edges(tsk_table_collection_t *tables)\n{\n int ret;\n tsk_edge_table_t edges;\n tsk_edge_t edge;\n tsk_id_t j, ret_id;\n\n /* Easy way to copy the metadata schema */\n ret = tsk_edge_table_copy(&tables->edges, &edges, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_clear(&edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = (tsk_id_t) tables->edges.num_rows - 1; j >= 0; j--) {\n ret = tsk_edge_table_get_row(&tables->edges, j, &edge);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_edge_table_add_row(&edges, edge.left, edge.right, edge.parent,\n edge.child, edge.metadata, edge.metadata_length);\n CU_ASSERT_FATAL(ret_id >= 0);\n }\n\n ret = tsk_edge_table_copy(&edges, &tables->edges, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_edge_table_free(&edges);\n}\n\nstatic void\nreverse_mutations(tsk_table_collection_t *tables)\n{\n int ret;\n tsk_mutation_table_t mutations;\n tsk_mutation_t mutation;\n tsk_id_t j, ret_id;\n tsk_id_t new_parent;\n tsk_id_t n = (tsk_id_t) tables->mutations.num_rows;\n\n ret = tsk_mutation_table_init(&mutations, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = n - 1; j >= 0; j--) {\n ret = tsk_mutation_table_get_row(&tables->mutations, j, &mutation);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n new_parent = (mutation.parent == TSK_NULL) ? TSK_NULL : n - mutation.parent - 1;\n ret_id = tsk_mutation_table_add_row(&mutations, mutation.site, mutation.node,\n new_parent, mutation.time, mutation.derived_state,\n mutation.derived_state_length, mutation.metadata, mutation.metadata_length);\n CU_ASSERT_FATAL(ret_id >= 0);\n }\n\n ret = tsk_mutation_table_copy(&mutations, &tables->mutations, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_mutation_table_free(&mutations);\n}\n\nstatic void\ninsert_edge_metadata(tsk_table_collection_t *tables)\n{\n int ret;\n tsk_edge_table_t edges;\n tsk_edge_t edge;\n tsk_id_t j, ret_id;\n char metadata[100];\n\n ret = tsk_edge_table_init(&edges, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < (tsk_id_t) tables->edges.num_rows; j++) {\n ret = tsk_edge_table_get_row(&tables->edges, j, &edge);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n snprintf(metadata, sizeof(metadata), \"md_%lld\\n\", (long long) j);\n ret_id = tsk_edge_table_add_row(&edges, edge.left, edge.right, edge.parent,\n edge.child, metadata, (tsk_size_t) strlen(metadata));\n CU_ASSERT_FATAL(ret_id >= 0);\n }\n ret = tsk_edge_table_copy(&edges, &tables->edges, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_edge_table_free(&edges);\n}\n\nstatic void\ntest_table_collection_equals_options(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tc1, tc2;\n\n char example_time_units[100] = \"An example of time units with unicode ⏰\";\n char example_metadata[100] = \"An example of metadata with unicode 🎄🌳🌴🌲🎋\";\n char example_metadata_schema[100]\n = \"An example of metadata schema with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_time_units_length = (tsk_size_t) strlen(example_time_units);\n tsk_size_t example_metadata_length = (tsk_size_t) strlen(example_metadata);\n tsk_size_t example_metadata_schema_length\n = (tsk_size_t) strlen(example_metadata_schema);\n\n // Test equality empty tables\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_init(&tc2, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_equals(&tc1, &tc2, 0);\n CU_ASSERT_TRUE(ret);\n\n // Adding some meat to the tables\n ret_id = tsk_node_table_add_row(&tc1.nodes, TSK_NODE_IS_SAMPLE, 0.0, 0, 0, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_node_table_add_row(&tc1.nodes, TSK_NODE_IS_SAMPLE, 1.0, 0, 0, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id\n = tsk_individual_table_add_row(&tc1.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_population_table_add_row(&tc1.populations, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tc1.edges, 0.0, 1.0, 1, 0, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tc1.sites, 0.2, \"A\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tc1.mutations, 0, 0, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n\n // Equality of empty vs non-empty\n ret = tsk_table_collection_equals(&tc1, &tc2, 0);\n CU_ASSERT_FALSE(ret);\n ret = tsk_table_collection_copy(&tc1, &tc2, TSK_NO_INIT);\n CU_ASSERT_EQUAL(ret, 0);\n\n // Equivalent except for time_units\n ret = tsk_table_collection_set_metadata(\n &tc1, example_time_units, example_time_units_length);\n CU_ASSERT_EQUAL(ret, 0);\n\n // Equivalent except for metadata\n ret = tsk_table_collection_set_metadata(\n &tc1, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_equals(&tc1, &tc2, TSK_CMP_IGNORE_TS_METADATA);\n CU_ASSERT_TRUE(ret);\n /* TSK_CMP_IGNORE_METADATA implies TSK_CMP_IGNORE_TS_METADATA */\n ret = tsk_table_collection_equals(&tc1, &tc2, TSK_CMP_IGNORE_METADATA);\n CU_ASSERT_TRUE(ret);\n ret = tsk_table_collection_equals(&tc1, &tc2, 0);\n CU_ASSERT_FALSE(ret);\n ret = tsk_table_collection_equals(&tc1, &tc2, TSK_CMP_IGNORE_PROVENANCE);\n CU_ASSERT_FALSE(ret);\n ret = tsk_table_collection_set_metadata(\n &tc2, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_equals(&tc1, &tc2, 0);\n CU_ASSERT_TRUE(ret);\n ret = tsk_table_collection_set_metadata_schema(\n &tc1, example_metadata_schema, example_metadata_schema_length);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_equals(&tc1, &tc2, TSK_CMP_IGNORE_TS_METADATA);\n CU_ASSERT_TRUE(ret);\n ret = tsk_table_collection_equals(&tc1, &tc2, 0);\n CU_ASSERT_FALSE(ret);\n ret = tsk_table_collection_set_metadata_schema(\n &tc2, example_metadata_schema, example_metadata_schema_length);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_equals(&tc1, &tc2, 0);\n CU_ASSERT_TRUE(ret);\n\n // Ignore provenance\n ret_id = tsk_provenance_table_add_row(&tc1.provenances, \"time\", 4, \"record\", 6);\n CU_ASSERT_EQUAL(ret_id, 0);\n ret = tsk_table_collection_equals(&tc1, &tc2, TSK_CMP_IGNORE_PROVENANCE);\n CU_ASSERT_TRUE(ret);\n ret = tsk_table_collection_equals(&tc1, &tc2, 0);\n CU_ASSERT_FALSE(ret);\n ret = tsk_table_collection_equals(&tc1, &tc2, TSK_CMP_IGNORE_TS_METADATA);\n CU_ASSERT_FALSE(ret);\n ret_id = tsk_provenance_table_add_row(&tc2.provenances, \"time\", 4, \"record\", 6);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_equals(&tc1, &tc2, TSK_CMP_IGNORE_PROVENANCE);\n CU_ASSERT_TRUE(ret);\n ret = tsk_table_collection_equals(&tc1, &tc2, 0);\n CU_ASSERT_TRUE(ret);\n\n // Ignore provenance timestamp\n ret_id = tsk_provenance_table_add_row(&tc1.provenances, \"time\", 4, \"record\", 6);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_provenance_table_add_row(&tc2.provenances, \"other\", 5, \"record\", 6);\n CU_ASSERT_FATAL(ret_id >= 0);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&tc1, &tc2, 0));\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, TSK_CMP_IGNORE_PROVENANCE));\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, TSK_CMP_IGNORE_TIMESTAMPS));\n\n // Ignore provenance and top-level metadata.\n ret = tsk_provenance_table_clear(&tc1.provenances);\n CU_ASSERT_EQUAL(ret, 0);\n example_metadata[0] = 'J';\n ret = tsk_table_collection_set_metadata(\n &tc1, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_equals(&tc1, &tc2, 0);\n CU_ASSERT_FALSE(ret);\n ret = tsk_table_collection_equals(\n &tc1, &tc2, TSK_CMP_IGNORE_TS_METADATA | TSK_CMP_IGNORE_PROVENANCE);\n CU_ASSERT_TRUE(ret);\n\n tsk_table_collection_free(&tc1);\n tsk_table_collection_free(&tc2);\n\n // Check what happens when one of the tables just differs by metadata.\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_init(&tc2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_population_table_add_row(&tc1.populations, \"metadata\", 8);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_population_table_add_row(&tc2.populations, \"\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&tc1, &tc2, 0));\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, TSK_CMP_IGNORE_METADATA));\n\n tsk_table_collection_free(&tc1);\n tsk_table_collection_free(&tc2);\n\n // Ignore tables\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_init(&tc2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_set_metadata(\n &tc1, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_set_metadata(\n &tc2, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n // Add one row for each table we're ignoring\n ret_id\n = tsk_individual_table_add_row(&tc1.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_node_table_add_row(&tc1.nodes, TSK_NODE_IS_SAMPLE, 0.0, 0, 0, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tc1.edges, 0.0, 1.0, 1, 0, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_migration_table_add_row(&tc1.migrations, 0, 0, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tc1.sites, 0.2, \"A\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tc1.mutations, 0, 0, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_population_table_add_row(&tc1.populations, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&tc1, &tc2, 0));\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, TSK_CMP_IGNORE_TABLES));\n\n tsk_table_collection_free(&tc1);\n tsk_table_collection_free(&tc2);\n\n // Ignore reference sequence\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_init(&tc2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_set_metadata(\n &tc1, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_set_metadata(\n &tc2, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n ret = tsk_reference_sequence_set_data(&tc1.reference_sequence, \"A\", 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&tc1, &tc2, 0));\n CU_ASSERT_TRUE(\n tsk_table_collection_equals(&tc1, &tc2, TSK_CMP_IGNORE_REFERENCE_SEQUENCE));\n\n tsk_table_collection_free(&tc1);\n tsk_table_collection_free(&tc2);\n}\n\nstatic void\ntest_table_collection_simplify_errors(void)\n{\n int ret;\n tsk_table_collection_t tables;\n tsk_id_t samples[] = { 0, 1 };\n tsk_id_t ret_id;\n const char *individuals = \"1 0.25 -2\\n\";\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n /* Bad samples */\n samples[0] = -1;\n ret = tsk_table_collection_simplify(&tables, samples, 2, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n samples[0] = 10;\n ret = tsk_table_collection_simplify(&tables, samples, 2, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n samples[0] = 0;\n\n /* Duplicate samples */\n samples[0] = 0;\n samples[1] = 0;\n ret = tsk_table_collection_simplify(&tables, samples, 2, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n samples[0] = 0;\n\n ret_id = tsk_site_table_add_row(&tables.sites, 0, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = tsk_table_collection_simplify(&tables, samples, 0, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SITE_POSITION);\n\n /* Out of order positions */\n tables.sites.position[0] = 0.5;\n ret = tsk_table_collection_simplify(&tables, samples, 0, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSORTED_SITES);\n\n /* Position out of bounds */\n tables.sites.position[0] = 1.5;\n ret = tsk_table_collection_simplify(&tables, samples, 0, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SITE_POSITION);\n tsk_site_table_truncate(&tables.sites, 0);\n tables.sites.position[0] = 0;\n\n /* Individual out of bounds */\n parse_individuals(individuals, &tables.individuals);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.num_rows, 1);\n ret = tsk_table_collection_simplify(&tables, samples, 0, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n\n /* TODO More tests for this: see\n * https://github.com/tskit-dev/msprime/issues/517 */\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_reference_sequence_state_machine(void)\n{\n\n tsk_reference_sequence_t r1;\n\n tsk_reference_sequence_init(&r1, 0);\n CU_ASSERT_EQUAL(r1.data, NULL);\n CU_ASSERT_EQUAL(r1.url, NULL);\n CU_ASSERT_EQUAL(r1.metadata, NULL);\n CU_ASSERT_EQUAL(r1.metadata_schema, NULL);\n CU_ASSERT_TRUE(tsk_reference_sequence_is_null(&r1));\n\n CU_ASSERT_EQUAL(tsk_reference_sequence_set_data(&r1, \"x\", 1), 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_is_null(&r1));\n /* Setting the value back to NULL makes the reference whole object NULL */\n CU_ASSERT_EQUAL(tsk_reference_sequence_set_data(&r1, NULL, 0), 0);\n CU_ASSERT_TRUE(tsk_reference_sequence_is_null(&r1));\n tsk_reference_sequence_free(&r1);\n CU_ASSERT_TRUE(tsk_reference_sequence_is_null(&r1));\n\n /* Any empty string is the same thing. */\n tsk_reference_sequence_init(&r1, 0);\n CU_ASSERT_EQUAL(tsk_reference_sequence_set_data(&r1, \"\", 0), 0);\n CU_ASSERT_TRUE(tsk_reference_sequence_is_null(&r1));\n tsk_reference_sequence_free(&r1);\n\n tsk_reference_sequence_init(&r1, 0);\n CU_ASSERT_EQUAL(tsk_reference_sequence_set_url(&r1, \"x\", 1), 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_is_null(&r1));\n tsk_reference_sequence_free(&r1);\n\n tsk_reference_sequence_init(&r1, 0);\n CU_ASSERT_EQUAL(tsk_reference_sequence_set_metadata(&r1, \"x\", 1), 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_is_null(&r1));\n tsk_reference_sequence_free(&r1);\n\n tsk_reference_sequence_init(&r1, 0);\n CU_ASSERT_EQUAL(tsk_reference_sequence_set_metadata_schema(&r1, \"x\", 1), 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_is_null(&r1));\n tsk_reference_sequence_free(&r1);\n\n tsk_reference_sequence_init(&r1, 0);\n CU_ASSERT_EQUAL(tsk_reference_sequence_set_metadata(&r1, \"x\", 1), 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_is_null(&r1));\n CU_ASSERT_EQUAL(tsk_reference_sequence_set_metadata_schema(&r1, \"x\", 1), 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_is_null(&r1));\n CU_ASSERT_EQUAL(tsk_reference_sequence_set_url(&r1, \"x\", 1), 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_is_null(&r1));\n CU_ASSERT_EQUAL(tsk_reference_sequence_set_data(&r1, \"x\", 1), 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_is_null(&r1));\n\n CU_ASSERT_EQUAL(tsk_reference_sequence_set_metadata(&r1, \"\", 0), 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_is_null(&r1));\n CU_ASSERT_EQUAL(tsk_reference_sequence_set_metadata_schema(&r1, \"\", 0), 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_is_null(&r1));\n CU_ASSERT_EQUAL(tsk_reference_sequence_set_url(&r1, \"\", 0), 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_is_null(&r1));\n CU_ASSERT_EQUAL(tsk_reference_sequence_set_data(&r1, \"\", 0), 0);\n CU_ASSERT_TRUE(tsk_reference_sequence_is_null(&r1));\n\n tsk_reference_sequence_free(&r1);\n}\n\nstatic void\ntest_reference_sequence_take(void)\n{\n int ret;\n tsk_reference_sequence_t r1;\n tsk_reference_sequence_t r2;\n const char *const_data = \"data\";\n const char *const_metadata = \"metadata\";\n char *takeset_data = strdup(const_data);\n char *takeset_metadata = strdup(const_metadata);\n\n ret = tsk_reference_sequence_init(&r1, 0);\n\n ret = tsk_reference_sequence_set_data(&r1, const_data, strlen(const_data));\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_reference_sequence_set_metadata(\n &r1, const_metadata, strlen(const_metadata));\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_reference_sequence_init(&r2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_equals(&r1, &r2, 0));\n ret = tsk_reference_sequence_takeset_data(&r2, takeset_data, strlen(takeset_data));\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_equals(&r1, &r2, 0));\n ret = tsk_reference_sequence_takeset_metadata(\n &r2, takeset_metadata, strlen(takeset_metadata));\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, 0));\n\n /* Writing over these with copies doesn't lose memory */\n ret = tsk_reference_sequence_set_data(&r2, const_data, strlen(const_data));\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_reference_sequence_set_metadata(\n &r2, const_metadata, strlen(const_metadata));\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, 0));\n\n /* The original copies are gone, make some new ones */\n takeset_data = strdup(const_data);\n takeset_metadata = strdup(const_metadata);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_reference_sequence_takeset_data(&r1, takeset_data, strlen(takeset_data));\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_reference_sequence_takeset_metadata(\n &r1, takeset_metadata, strlen(takeset_metadata));\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, 0));\n\n tsk_reference_sequence_free(&r1);\n tsk_reference_sequence_free(&r2);\n}\n\nstatic void\ntest_reference_sequence(void)\n{\n int ret;\n tsk_reference_sequence_t r1;\n tsk_reference_sequence_t r2;\n\n const char example_data[100] = \"An example string with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_data_length = (tsk_size_t) strlen(example_data);\n const char example_url[100] = \"An example url with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_url_length = (tsk_size_t) strlen(example_url);\n const char example_metadata[100] = \"An example metadata with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_metadata_length = (tsk_size_t) strlen(example_metadata);\n const char example_schema[100] = \"An example schema with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_schema_length = (tsk_size_t) strlen(example_schema);\n\n tsk_reference_sequence_init(&r1, 0);\n tsk_reference_sequence_init(&r2, 0);\n\n /* NULL sequences are initially equal */\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, 0));\n\n ret = tsk_reference_sequence_set_data(&r1, example_data, example_data_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_equals(&r1, &r2, 0));\n\n ret = tsk_reference_sequence_set_data(&r1, \"\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, 0));\n\n ret = tsk_reference_sequence_set_data(&r2, \"\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, 0));\n\n ret = tsk_reference_sequence_set_data(&r1, example_data, example_data_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_equals(&r1, &r2, 0));\n\n ret = tsk_reference_sequence_set_data(&r2, example_data, example_data_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, 0));\n\n ret = tsk_reference_sequence_set_url(&r1, example_url, example_url_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_equals(&r1, &r2, 0));\n ret = tsk_reference_sequence_set_url(&r2, example_url, example_url_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, 0));\n\n ret = tsk_reference_sequence_set_metadata(\n &r1, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_equals(&r1, &r2, 0));\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, TSK_CMP_IGNORE_METADATA));\n ret = tsk_reference_sequence_set_metadata(\n &r2, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, 0));\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, TSK_CMP_IGNORE_METADATA));\n\n ret = tsk_reference_sequence_set_metadata_schema(\n &r1, example_schema, example_schema_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_reference_sequence_equals(&r1, &r2, 0));\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, TSK_CMP_IGNORE_METADATA));\n ret = tsk_reference_sequence_set_metadata_schema(\n &r2, example_schema, example_schema_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, 0));\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, TSK_CMP_IGNORE_METADATA));\n\n // Test copy\n tsk_reference_sequence_free(&r1);\n tsk_reference_sequence_free(&r2);\n\n tsk_reference_sequence_init(&r1, 0);\n ret = tsk_reference_sequence_set_data(&r1, example_data, example_data_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_reference_sequence_copy(&r1, &r2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, 0));\n\n ret = tsk_reference_sequence_set_url(&r1, example_url, example_url_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_reference_sequence_copy(&r1, &r2, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, 0));\n\n ret = tsk_reference_sequence_set_metadata(\n &r1, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_reference_sequence_copy(&r1, &r2, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, 0));\n\n ret = tsk_reference_sequence_set_metadata_schema(\n &r1, example_schema, example_schema_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_reference_sequence_copy(&r1, &r2, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_reference_sequence_equals(&r1, &r2, 0));\n\n tsk_reference_sequence_free(&r1);\n tsk_reference_sequence_free(&r2);\n}\n\nstatic void\ntest_table_collection_reference_sequence(void)\n{\n int ret;\n tsk_table_collection_t tc1, tc2;\n\n char example_data[100] = \"An example string with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_data_length = (tsk_size_t) strlen(example_data);\n char example_url[100] = \"An example url with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_url_length = (tsk_size_t) strlen(example_url);\n char example_metadata[100] = \"An example metadata with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_metadata_length = (tsk_size_t) strlen(example_metadata);\n char example_schema[100] = \"An example schema with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_schema_length = (tsk_size_t) strlen(example_schema);\n\n // Test equality\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_init(&tc2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n ret = tsk_reference_sequence_set_data(\n &tc1.reference_sequence, example_data, example_data_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n ret = tsk_reference_sequence_set_data(\n &tc2.reference_sequence, example_data, example_data_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n ret = tsk_reference_sequence_set_url(\n &tc1.reference_sequence, example_url, example_url_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&tc1, &tc2, 0));\n ret = tsk_reference_sequence_set_url(\n &tc2.reference_sequence, example_url, example_url_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n ret = tsk_reference_sequence_set_metadata(\n &tc1.reference_sequence, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&tc1, &tc2, 0));\n ret = tsk_reference_sequence_set_metadata(\n &tc2.reference_sequence, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n ret = tsk_reference_sequence_set_metadata_schema(\n &tc1.reference_sequence, example_schema, example_schema_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&tc1, &tc2, 0));\n ret = tsk_reference_sequence_set_metadata_schema(\n &tc2.reference_sequence, example_schema, example_schema_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n // Test copy\n tsk_table_collection_free(&tc1);\n tsk_table_collection_free(&tc2);\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_reference_sequence_set_data(\n &tc1.reference_sequence, example_data, example_data_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_copy(&tc1, &tc2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n ret = tsk_reference_sequence_set_url(\n &tc1.reference_sequence, example_url, example_url_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_copy(&tc1, &tc2, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n ret = tsk_reference_sequence_set_metadata(\n &tc1.reference_sequence, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_copy(&tc1, &tc2, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n ret = tsk_reference_sequence_set_metadata_schema(\n &tc1.reference_sequence, example_schema, example_schema_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_copy(&tc1, &tc2, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n tsk_table_collection_free(&tc1);\n tsk_table_collection_free(&tc2);\n\n // Test dump and load\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tc1.sequence_length = 1.0;\n ret = tsk_reference_sequence_set_data(\n &tc1.reference_sequence, example_data, example_data_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_reference_sequence_set_url(\n &tc1.reference_sequence, example_url, example_url_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_reference_sequence_set_metadata(\n &tc1.reference_sequence, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_reference_sequence_set_metadata_schema(\n &tc1.reference_sequence, example_schema, example_schema_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_dump(&tc1, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tc2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n tsk_table_collection_free(&tc1);\n tsk_table_collection_free(&tc2);\n}\n\nstatic void\ntest_table_collection_has_reference_sequence(void)\n{\n int ret;\n tsk_table_collection_t tc;\n\n ret = tsk_table_collection_init(&tc, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tc.sequence_length = 1.0;\n\n CU_ASSERT_FALSE(tsk_table_collection_has_reference_sequence(&tc));\n ret = tsk_reference_sequence_set_data(&tc.reference_sequence, \"A\", 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_has_reference_sequence(&tc));\n /* Goes back to NULL by setting a empty string. See\n * test_reference_sequence_state_machine for detailed tests. */\n ret = tsk_reference_sequence_set_data(&tc.reference_sequence, \"\", 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_has_reference_sequence(&tc));\n\n tsk_table_collection_free(&tc);\n}\n\nstatic void\ntest_table_collection_metadata(void)\n{\n int ret;\n tsk_table_collection_t tc1, tc2;\n\n char example_metadata[100] = \"An example of metadata with unicode 🎄🌳🌴🌲🎋\";\n char *takeset_metadata;\n char example_metadata_schema[100]\n = \"An example of metadata schema with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_metadata_length = (tsk_size_t) strlen(example_metadata);\n tsk_size_t example_metadata_schema_length\n = (tsk_size_t) strlen(example_metadata_schema);\n\n // Test equality\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_init(&tc2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n ret = tsk_table_collection_set_metadata(\n &tc1, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&tc1, &tc2, 0));\n ret = tsk_table_collection_set_metadata(\n &tc2, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n ret = tsk_table_collection_set_metadata_schema(\n &tc1, example_metadata_schema, example_metadata_schema_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&tc1, &tc2, 0));\n ret = tsk_table_collection_set_metadata_schema(\n &tc2, example_metadata_schema, example_metadata_schema_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n // Test copy\n tsk_table_collection_free(&tc1);\n tsk_table_collection_free(&tc2);\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_set_metadata(\n &tc1, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_copy(&tc1, &tc2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n ret = tsk_table_collection_set_metadata_schema(\n &tc1, example_metadata_schema, example_metadata_schema_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_table_collection_free(&tc2);\n ret = tsk_table_collection_copy(&tc1, &tc2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n // Test dump and load with empty metadata and schema\n tsk_table_collection_free(&tc1);\n tsk_table_collection_free(&tc2);\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tc1.sequence_length = 1.0;\n ret = tsk_table_collection_dump(&tc1, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tc2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n // Test dump and load with set metadata and schema\n tsk_table_collection_free(&tc1);\n tsk_table_collection_free(&tc2);\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tc1.sequence_length = 1.0;\n ret = tsk_table_collection_set_metadata(\n &tc1, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_set_metadata_schema(\n &tc1, example_metadata_schema, example_metadata_schema_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_dump(&tc1, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tc2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n tsk_table_collection_free(&tc1);\n tsk_table_collection_free(&tc2);\n\n takeset_metadata = tsk_malloc(example_metadata_length * sizeof(char));\n CU_ASSERT_FATAL(takeset_metadata != NULL);\n memcpy(takeset_metadata, &example_metadata,\n (size_t) (example_metadata_length * sizeof(char)));\n\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_takeset_metadata(\n &tc1, takeset_metadata, example_metadata_length);\n CU_ASSERT_EQUAL(\n tsk_memcmp(tc1.metadata, &example_metadata, example_metadata_length), 0);\n tsk_table_collection_free(&tc1);\n}\n\nstatic void\ntest_table_collection_time_units(void)\n{\n int ret;\n tsk_table_collection_t tc1, tc2;\n\n char example_time_units[100] = \"An example of time units with unicode ⏰\";\n tsk_size_t example_time_units_length = (tsk_size_t) strlen(example_time_units);\n\n // Test equality\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_init(&tc2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n ret = tsk_table_collection_set_time_units(\n &tc1, example_time_units, example_time_units_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&tc1, &tc2, 0));\n ret = tsk_table_collection_set_time_units(\n &tc2, example_time_units, example_time_units_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n // Test copy\n tsk_table_collection_free(&tc1);\n tsk_table_collection_free(&tc2);\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_set_time_units(\n &tc1, example_time_units, example_time_units_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_copy(&tc1, &tc2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n // Test dump and load with default time_units\n tsk_table_collection_free(&tc1);\n tsk_table_collection_free(&tc2);\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ret, strncmp(tc1.time_units, TSK_TIME_UNITS_UNKNOWN, 7));\n tc1.sequence_length = 1.0;\n ret = tsk_table_collection_dump(&tc1, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tc2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n\n // Test dump and load with set time_units and schema\n tsk_table_collection_free(&tc1);\n tsk_table_collection_free(&tc2);\n ret = tsk_table_collection_init(&tc1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tc1.sequence_length = 1.0;\n ret = tsk_table_collection_set_time_units(\n &tc1, example_time_units, example_time_units_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_dump(&tc1, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tc2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tc1, &tc2, 0));\n tsk_table_collection_free(&tc1);\n tsk_table_collection_free(&tc2);\n}\n\nstatic void\ntest_node_table(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_node_table_t table, table2;\n tsk_node_t node, node2;\n tsk_size_t num_rows = 100;\n tsk_id_t j;\n tsk_flags_t *flags;\n tsk_id_t *population;\n double *time;\n tsk_id_t *individual;\n char *metadata;\n tsk_size_t *metadata_offset;\n const char *test_metadata = \"test\";\n tsk_size_t test_metadata_length = 4;\n char metadata_copy[test_metadata_length + 1];\n tsk_id_t row_subset[6] = { 1, 9, 1, 0, 2, 2 };\n tsk_size_t num_row_subset = 6;\n\n metadata_copy[test_metadata_length] = '\\0';\n ret = tsk_node_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_node_table_set_max_rows_increment(&table, 1);\n tsk_node_table_set_max_metadata_length_increment(&table, 1);\n tsk_node_table_print_state(&table, _devnull);\n ret = tsk_node_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n ret_id = tsk_node_table_add_row(&table, (tsk_flags_t) j, (double) j, j, j,\n test_metadata, test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n CU_ASSERT_EQUAL(table.flags[j], (tsk_flags_t) j);\n CU_ASSERT_EQUAL(table.time[j], j);\n CU_ASSERT_EQUAL(table.population[j], j);\n CU_ASSERT_EQUAL(table.individual[j], j);\n CU_ASSERT_EQUAL(table.num_rows, (tsk_size_t) j + 1);\n CU_ASSERT_EQUAL(\n table.metadata_length, (tsk_size_t) (j + 1) * test_metadata_length);\n CU_ASSERT_EQUAL(table.metadata_offset[j + 1], table.metadata_length);\n /* check the metadata */\n tsk_memcpy(metadata_copy, table.metadata + table.metadata_offset[j],\n test_metadata_length);\n CU_ASSERT_NSTRING_EQUAL(metadata_copy, test_metadata, test_metadata_length);\n ret = tsk_node_table_get_row(&table, (tsk_id_t) j, &node);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(node.id, j);\n CU_ASSERT_EQUAL(node.flags, (tsk_size_t) j);\n CU_ASSERT_EQUAL(node.time, j);\n CU_ASSERT_EQUAL(node.population, j);\n CU_ASSERT_EQUAL(node.individual, j);\n CU_ASSERT_EQUAL(node.metadata_length, test_metadata_length);\n CU_ASSERT_NSTRING_EQUAL(node.metadata, test_metadata, test_metadata_length);\n }\n\n /* Test equality with and without metadata */\n tsk_node_table_copy(&table, &table2, 0);\n CU_ASSERT_TRUE(tsk_node_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_node_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Change the metadata values */\n table2.metadata[0] = 0;\n CU_ASSERT_FALSE(tsk_node_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_node_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Change the last metadata entry */\n table2.metadata_offset[table2.num_rows]\n = table2.metadata_offset[table2.num_rows - 1];\n CU_ASSERT_FALSE(tsk_node_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_node_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Delete all metadata */\n tsk_memset(table2.metadata_offset, 0,\n (table2.num_rows + 1) * sizeof(*table2.metadata_offset));\n CU_ASSERT_FALSE(tsk_node_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_node_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n tsk_node_table_free(&table2);\n\n CU_ASSERT_EQUAL(tsk_node_table_get_row(&table, (tsk_id_t) num_rows, &node),\n TSK_ERR_NODE_OUT_OF_BOUNDS);\n tsk_node_table_print_state(&table, _devnull);\n ret = tsk_node_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_node_table_clear(&table);\n CU_ASSERT_EQUAL(table.num_rows, 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n num_rows *= 2;\n flags = tsk_malloc(num_rows * sizeof(tsk_flags_t));\n CU_ASSERT_FATAL(flags != NULL);\n tsk_memset(flags, 1, num_rows * sizeof(tsk_flags_t));\n population = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(population != NULL);\n tsk_memset(population, 2, num_rows * sizeof(tsk_id_t));\n time = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(time != NULL);\n tsk_memset(time, 0, num_rows * sizeof(double));\n individual = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(individual != NULL);\n tsk_memset(individual, 3, num_rows * sizeof(tsk_id_t));\n metadata = tsk_malloc(num_rows * sizeof(char));\n tsk_memset(metadata, 'a', num_rows * sizeof(char));\n CU_ASSERT_FATAL(metadata != NULL);\n metadata_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(metadata_offset != NULL);\n for (j = 0; j < (tsk_id_t) num_rows + 1; j++) {\n metadata_offset[j] = (tsk_size_t) j;\n }\n ret = tsk_node_table_set_columns(&table, num_rows, flags, time, population,\n individual, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.flags, flags, num_rows * sizeof(tsk_flags_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.population, population, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.individual, individual, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, num_rows);\n tsk_node_table_print_state(&table, _devnull);\n ret = tsk_node_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Append another num_rows onto the end */\n ret = tsk_node_table_append_columns(&table, num_rows, flags, time, population,\n individual, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.flags, flags, num_rows * sizeof(tsk_flags_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.flags + num_rows, flags, num_rows * sizeof(tsk_flags_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.population, population, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.population + num_rows, population, num_rows * sizeof(tsk_id_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.time + num_rows, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.individual, individual, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.individual + num_rows, individual, num_rows * sizeof(tsk_id_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata + num_rows, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.num_rows, 2 * num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, 2 * num_rows);\n tsk_node_table_print_state(&table, _devnull);\n ret = tsk_node_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Truncate back to the original number of rows. */\n ret = tsk_node_table_truncate(&table, num_rows);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.flags, flags, num_rows * sizeof(tsk_flags_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.population, population, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.individual, individual, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, num_rows);\n\n ret = tsk_node_table_truncate(&table, num_rows + 1);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_TABLE_POSITION);\n\n /* If population is NULL it should be set to -1. If metadata is NULL all metadatas\n * should be set to the empty string. If individual is NULL it should be set to -1.\n */\n num_rows = 10;\n tsk_memset(population, 0xff, num_rows * sizeof(tsk_id_t));\n tsk_memset(individual, 0xff, num_rows * sizeof(tsk_id_t));\n ret = tsk_node_table_set_columns(\n &table, num_rows, flags, time, NULL, NULL, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.flags, flags, num_rows * sizeof(tsk_flags_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.population, population, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.individual, individual, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n num_rows * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, num_rows);\n\n /* flags and time cannot be NULL */\n ret = tsk_node_table_set_columns(\n &table, num_rows, NULL, time, population, individual, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_node_table_set_columns(&table, num_rows, flags, NULL, population,\n individual, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_node_table_set_columns(\n &table, num_rows, flags, time, population, individual, NULL, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_node_table_set_columns(\n &table, num_rows, flags, time, population, individual, metadata, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* if metadata and metadata_offset are both null, all metadatas are zero length */\n num_rows = 10;\n tsk_memset(metadata_offset, 0, (num_rows + 1) * sizeof(tsk_size_t));\n ret = tsk_node_table_set_columns(\n &table, num_rows, flags, time, NULL, NULL, NULL, NULL);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.flags, flags, num_rows * sizeof(tsk_flags_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n ret = tsk_node_table_append_columns(\n &table, num_rows, flags, time, NULL, NULL, NULL, NULL);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.flags, flags, num_rows * sizeof(tsk_flags_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.flags + num_rows, flags, num_rows * sizeof(tsk_flags_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.time + num_rows, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset + num_rows, metadata_offset,\n num_rows * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, 2 * num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n tsk_node_table_print_state(&table, _devnull);\n ret = tsk_node_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Test extend method */\n ret = tsk_node_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_node_table_init(&table2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Can't extend from self */\n ret = tsk_node_table_extend(&table, &table, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n\n /* Two empty tables */\n CU_ASSERT_TRUE(tsk_node_table_equals(&table, &table2, 0));\n ret = tsk_node_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_node_table_equals(&table, &table2, 0));\n\n /* Row out of bounds */\n ret = tsk_node_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n /* Num rows out of bounds */\n ret = tsk_node_table_extend(&table, &table2, num_rows * 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n /* Copy rows in order if index NULL */\n ret = tsk_node_table_set_columns(&table2, num_rows, flags, time, population,\n individual, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_node_table_equals(&table, &table2, 0));\n ret = tsk_node_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_node_table_equals(&table, &table2, 0));\n\n /* Copy nothing if index not NULL but length zero */\n ret = tsk_node_table_extend(&table, &table2, 0, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_node_table_equals(&table, &table2, 0));\n\n /* Copy first N rows in order if index NULL */\n ret = tsk_node_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_node_table_extend(&table, &table2, num_rows / 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_node_table_truncate(&table2, num_rows / 2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_node_table_equals(&table, &table2, 0));\n ret = tsk_node_table_set_columns(&table2, num_rows, flags, time, population,\n individual, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Copy a subset */\n ret = tsk_node_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_node_table_equals(&table, &table2, 0));\n ret = tsk_node_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < (tsk_id_t) num_row_subset; j++) {\n ret = tsk_node_table_get_row(&table, j, &node);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_node_table_get_row(&table2, row_subset[j], &node2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(node.flags, node2.flags);\n CU_ASSERT_EQUAL(node.time, node2.time);\n CU_ASSERT_EQUAL(node.population, node2.population);\n CU_ASSERT_EQUAL(node.individual, node2.individual);\n CU_ASSERT_EQUAL(node.metadata_length, node2.metadata_length);\n CU_ASSERT_EQUAL(tsk_memcmp(node.metadata, node2.metadata,\n node.metadata_length * sizeof(*node.metadata)),\n 0);\n }\n\n ret = tsk_node_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(table.metadata_schema_length, 0);\n CU_ASSERT_EQUAL(table.metadata_schema, NULL);\n const char *example = \"An example of metadata schema with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_length = (tsk_size_t) strlen(example);\n const char *example2 = \"A different example 🎄🌳🌴🌲🎋\";\n tsk_size_t example2_length = (tsk_size_t) strlen(example);\n tsk_node_table_set_metadata_schema(&table, example, example_length);\n CU_ASSERT_EQUAL(table.metadata_schema_length, example_length);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_schema, example, example_length), 0);\n\n tsk_node_table_copy(&table, &table2, TSK_NO_INIT);\n CU_ASSERT_EQUAL(table.metadata_schema_length, table2.metadata_schema_length);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata_schema, table2.metadata_schema, example_length), 0);\n tsk_node_table_set_metadata_schema(&table2, example, example_length);\n CU_ASSERT_TRUE(tsk_node_table_equals(&table, &table2, 0));\n tsk_node_table_set_metadata_schema(&table2, example2, example2_length);\n CU_ASSERT_FALSE(tsk_node_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_node_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n\n tsk_node_table_clear(&table);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(table.num_rows, 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n tsk_node_table_free(&table);\n CU_ASSERT_EQUAL(ret, 0);\n tsk_node_table_free(&table2);\n CU_ASSERT_EQUAL(ret, 0);\n free(flags);\n free(population);\n free(time);\n free(metadata);\n free(metadata_offset);\n free(individual);\n}\n\nstatic void\ntest_node_table_takeset(void)\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_node_table_t source_table, table;\n tsk_size_t num_rows = 100;\n tsk_id_t j;\n tsk_flags_t *flags;\n double *time;\n tsk_id_t *population;\n tsk_id_t *individual;\n char *metadata;\n tsk_size_t *metadata_offset;\n const char *test_metadata = \"test\";\n tsk_size_t test_metadata_length = 4;\n tsk_size_t zeros[num_rows + 1];\n tsk_id_t neg_ones[num_rows];\n\n tsk_memset(zeros, 0, (num_rows + 1) * sizeof(tsk_size_t));\n tsk_memset(neg_ones, 0xff, num_rows * sizeof(tsk_id_t));\n /* Make a table to copy from */\n ret = tsk_node_table_init(&source_table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n ret_id = tsk_node_table_add_row(&source_table, (tsk_flags_t) j, (double) j + 1,\n j + 2, j + 3, test_metadata, test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n }\n\n /* Prepare arrays to be taken */\n flags = tsk_malloc(num_rows * sizeof(tsk_flags_t));\n CU_ASSERT_FATAL(flags != NULL);\n tsk_memcpy(flags, source_table.flags, num_rows * sizeof(tsk_flags_t));\n time = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(time != NULL);\n tsk_memcpy(time, source_table.time, num_rows * sizeof(double));\n population = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(population != NULL);\n tsk_memcpy(population, source_table.population, num_rows * sizeof(tsk_id_t));\n individual = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(individual != NULL);\n tsk_memcpy(individual, source_table.individual, num_rows * sizeof(tsk_id_t));\n metadata = tsk_malloc(num_rows * test_metadata_length * sizeof(char));\n CU_ASSERT_FATAL(metadata != NULL);\n tsk_memcpy(\n metadata, source_table.metadata, num_rows * test_metadata_length * sizeof(char));\n metadata_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(metadata_offset != NULL);\n tsk_memcpy(metadata_offset, source_table.metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t));\n\n ret = tsk_node_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Add one row so that we can check takeset frees it */\n ret_id = tsk_node_table_add_row(\n &table, (tsk_flags_t) 1, 2, 3, 4, test_metadata, test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n ret = tsk_node_table_takeset_columns(&table, num_rows, flags, time, population,\n individual, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_node_table_equals(&source_table, &table, 0));\n\n /* Test error states, all of these must not take the array, or free existing */\n /* metadata and metadata offset must be simultaneously NULL or not */\n ret = tsk_node_table_takeset_columns(\n &table, num_rows, NULL, time, population, individual, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_node_table_takeset_columns(&table, num_rows, flags, NULL, population,\n individual, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_node_table_takeset_columns(\n &table, num_rows, flags, time, population, individual, NULL, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_node_table_takeset_columns(\n &table, num_rows, flags, time, population, individual, metadata, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* Truncation after takeset keeps memory and max_rows */\n ret = tsk_node_table_clear(&table);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(table.max_rows, num_rows);\n\n flags = tsk_malloc(num_rows * sizeof(tsk_flags_t));\n CU_ASSERT_FATAL(flags != NULL);\n tsk_memcpy(flags, source_table.flags, num_rows * sizeof(tsk_flags_t));\n time = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(time != NULL);\n tsk_memcpy(time, source_table.time, num_rows * sizeof(double));\n /* if metadata and offset are both null, all entries are zero length,\n individual and population default to -1 */\n num_rows = 10;\n ret = tsk_node_table_takeset_columns(\n &table, num_rows, flags, time, NULL, NULL, NULL, NULL);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.population, neg_ones, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.individual, neg_ones, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata_offset, zeros, (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n ret = tsk_node_table_free(&table);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_node_table_free(&source_table);\n CU_ASSERT_EQUAL(ret, 0);\n}\n\nstatic void\ntest_node_table_update_row(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_node_table_t table;\n tsk_node_t row;\n const char *metadata = \"ABC\";\n\n ret = tsk_node_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_node_table_add_row(&table, 0, 1.0, 2, 3, metadata, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(&table, 1, 2.0, 3, 4, metadata, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(&table, 2, 3.0, 4, 5, metadata, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_node_table_update_row(&table, 0, 1, 2.0, 3, 4, &metadata[1], 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_node_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.flags, 1);\n CU_ASSERT_EQUAL_FATAL(row.time, 2.0);\n CU_ASSERT_EQUAL_FATAL(row.population, 3);\n CU_ASSERT_EQUAL_FATAL(row.individual, 4);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_node_table_update_row(&table, 0, row.flags + 1, row.time + 1,\n row.population + 1, row.individual + 1, row.metadata, row.metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_node_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.flags, 2);\n CU_ASSERT_EQUAL_FATAL(row.time, 3.0);\n CU_ASSERT_EQUAL_FATAL(row.population, 4);\n CU_ASSERT_EQUAL_FATAL(row.individual, 5);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_node_table_update_row(&table, 0, 0, 0, 0, 0, metadata, 3);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_node_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.flags, 0);\n CU_ASSERT_EQUAL_FATAL(row.time, 0);\n CU_ASSERT_EQUAL_FATAL(row.population, 0);\n CU_ASSERT_EQUAL_FATAL(row.individual, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.metadata[2], 'C');\n\n ret = tsk_node_table_update_row(&table, 1, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_node_table_get_row(&table, 1, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.flags, 0);\n CU_ASSERT_EQUAL_FATAL(row.time, 0);\n CU_ASSERT_EQUAL_FATAL(row.population, 0);\n CU_ASSERT_EQUAL_FATAL(row.individual, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 0);\n\n ret = tsk_node_table_get_row(&table, 2, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.flags, 2);\n CU_ASSERT_EQUAL_FATAL(row.time, 3.0);\n CU_ASSERT_EQUAL_FATAL(row.population, 4);\n CU_ASSERT_EQUAL_FATAL(row.individual, 5);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.metadata[2], 'C');\n\n ret = tsk_node_table_update_row(&table, 3, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n tsk_node_table_free(&table);\n}\n\nstatic void\ntest_node_table_keep_rows(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_node_table_t source, t1, t2;\n tsk_node_t row;\n tsk_bool_t keep[3] = { 1, 1, 1 };\n tsk_id_t id_map[3];\n const char *metadata = \"ABC\";\n tsk_id_t indexes[] = { 0, 1, 2 };\n\n ret = tsk_node_table_init(&source, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_node_table_add_row(&source, 0, 1.0, 2, 3, metadata, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(&source, 1, 2.0, 3, 4, metadata, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(&source, 2, 3.0, 4, 5, metadata, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_node_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_node_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_node_table_equals(&t1, &source, 0));\n\n ret = tsk_node_table_keep_rows(&t1, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_node_table_equals(&t1, &source, 0));\n CU_ASSERT_EQUAL_FATAL(id_map[0], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], 2);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n ret = tsk_node_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_node_table_copy(&source, &t1, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[0] = 0;\n keep[1] = 1;\n keep[2] = 0;\n ret = tsk_node_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 1);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_node_table_get_row(&t1, 0, &row);\n CU_ASSERT_EQUAL_FATAL(row.flags, 1);\n CU_ASSERT_EQUAL_FATAL(row.time, 2.0);\n CU_ASSERT_EQUAL_FATAL(row.population, 3);\n CU_ASSERT_EQUAL_FATAL(row.individual, 4);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 2);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n\n tsk_node_table_free(&t1);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n /* Keeping first n rows equivalent to truncate */\n for (j = 0; j < source.num_rows; j++) {\n ret = tsk_node_table_copy(&source, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_node_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_node_table_truncate(&t1, j + 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[j] = 1;\n ret = tsk_node_table_keep_rows(&t2, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_node_table_equals(&t1, &t2, 0));\n\n /* Adding the remaining rows back on to the table gives the original\n * table */\n ret = tsk_node_table_extend(\n &t2, &source, source.num_rows - j - 1, indexes + j + 1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_node_table_equals(&source, &t2, 0));\n\n tsk_node_table_free(&t1);\n tsk_node_table_free(&t2);\n }\n\n tsk_node_table_free(&source);\n}\n\nstatic void\ntest_edge_table_with_options(tsk_flags_t options)\n{\n int ret;\n tsk_edge_table_t table, table2;\n tsk_size_t num_rows = 100;\n tsk_id_t j, ret_id;\n tsk_edge_t edge, edge2;\n tsk_id_t *parent, *child;\n double *left, *right;\n char *metadata;\n tsk_size_t *metadata_offset;\n const char *test_metadata = \"test\";\n tsk_size_t test_metadata_length = 4;\n char metadata_copy[test_metadata_length + 1];\n tsk_id_t row_subset[6] = { 1, 9, 1, 0, 2, 2 };\n tsk_size_t num_row_subset = 6;\n\n metadata_copy[test_metadata_length] = '\\0';\n ret = tsk_edge_table_init(&table, options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_edge_table_set_max_rows_increment(&table, 1);\n tsk_edge_table_set_max_metadata_length_increment(&table, 1);\n tsk_edge_table_print_state(&table, _devnull);\n ret = tsk_edge_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n if (options & TSK_TABLE_NO_METADATA) {\n ret_id = tsk_edge_table_add_row(&table, (double) j, (double) j, j, j,\n test_metadata, test_metadata_length);\n CU_ASSERT_EQUAL(ret_id, TSK_ERR_METADATA_DISABLED);\n ret_id\n = tsk_edge_table_add_row(&table, (double) j, (double) j, j, j, NULL, 0);\n } else {\n ret_id = tsk_edge_table_add_row(&table, (double) j, (double) j, j, j,\n test_metadata, test_metadata_length);\n }\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n CU_ASSERT_EQUAL(table.left[j], j);\n CU_ASSERT_EQUAL(table.right[j], j);\n CU_ASSERT_EQUAL(table.parent[j], j);\n CU_ASSERT_EQUAL(table.child[j], j);\n CU_ASSERT_EQUAL(table.num_rows, (tsk_size_t) j + 1);\n if (options & TSK_TABLE_NO_METADATA) {\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n CU_ASSERT_EQUAL(table.metadata, NULL);\n CU_ASSERT_EQUAL(table.metadata_offset, NULL);\n } else {\n CU_ASSERT_EQUAL(\n table.metadata_length, (tsk_size_t) (j + 1) * test_metadata_length);\n CU_ASSERT_EQUAL(table.metadata_offset[j + 1], table.metadata_length);\n /* check the metadata */\n tsk_memcpy(metadata_copy, table.metadata + table.metadata_offset[j],\n test_metadata_length);\n CU_ASSERT_NSTRING_EQUAL(metadata_copy, test_metadata, test_metadata_length);\n }\n\n ret = tsk_edge_table_get_row(&table, (tsk_id_t) j, &edge);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(edge.id, j);\n CU_ASSERT_EQUAL(edge.left, j);\n CU_ASSERT_EQUAL(edge.right, j);\n CU_ASSERT_EQUAL(edge.parent, j);\n CU_ASSERT_EQUAL(edge.child, j);\n if (options & TSK_TABLE_NO_METADATA) {\n CU_ASSERT_EQUAL(edge.metadata_length, 0);\n CU_ASSERT_EQUAL(edge.metadata, NULL);\n } else {\n CU_ASSERT_EQUAL(edge.metadata_length, test_metadata_length);\n CU_ASSERT_NSTRING_EQUAL(edge.metadata, test_metadata, test_metadata_length);\n }\n }\n ret = tsk_edge_table_get_row(&table, (tsk_id_t) num_rows, &edge);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n tsk_edge_table_print_state(&table, _devnull);\n ret = tsk_edge_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n num_rows *= 2;\n left = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(left != NULL);\n tsk_memset(left, 0, num_rows * sizeof(double));\n right = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(right != NULL);\n tsk_memset(right, 0, num_rows * sizeof(double));\n parent = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(parent != NULL);\n tsk_memset(parent, 1, num_rows * sizeof(tsk_id_t));\n child = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(child != NULL);\n tsk_memset(child, 1, num_rows * sizeof(tsk_id_t));\n metadata = tsk_malloc(num_rows * sizeof(char));\n tsk_memset(metadata, 'a', num_rows * sizeof(char));\n CU_ASSERT_FATAL(metadata != NULL);\n metadata_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(metadata_offset != NULL);\n for (j = 0; j < (tsk_id_t) num_rows + 1; j++) {\n metadata_offset[j] = (tsk_size_t) j;\n }\n if (options & TSK_TABLE_NO_METADATA) {\n ret = tsk_edge_table_set_columns(\n &table, num_rows, left, right, parent, child, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_METADATA_DISABLED);\n ret = tsk_edge_table_set_columns(\n &table, num_rows, left, right, parent, child, NULL, NULL);\n } else {\n ret = tsk_edge_table_set_columns(\n &table, num_rows, left, right, parent, child, metadata, metadata_offset);\n }\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.left, left, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.right, right, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parent, parent, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.child, child, num_rows * sizeof(tsk_id_t)), 0);\n if (options & TSK_TABLE_NO_METADATA) {\n CU_ASSERT_EQUAL(table.metadata, NULL);\n CU_ASSERT_EQUAL(table.metadata_offset, NULL);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n } else {\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.metadata_length, num_rows);\n }\n\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n\n /* Append another num_rows to the end. */\n if (options & TSK_TABLE_NO_METADATA) {\n ret = tsk_edge_table_append_columns(\n &table, num_rows, left, right, parent, child, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_METADATA_DISABLED);\n ret = tsk_edge_table_append_columns(\n &table, num_rows, left, right, parent, child, NULL, NULL);\n } else {\n ret = tsk_edge_table_append_columns(\n &table, num_rows, left, right, parent, child, metadata, metadata_offset);\n }\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.left, left, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.left + num_rows, left, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.right, right, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.right + num_rows, right, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parent, parent, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.parent + num_rows, parent, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.child, child, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.child + num_rows, child, num_rows * sizeof(tsk_id_t)), 0);\n if (options & TSK_TABLE_NO_METADATA) {\n CU_ASSERT_EQUAL(table.metadata, NULL);\n CU_ASSERT_EQUAL(table.metadata_offset, NULL);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n } else {\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata + num_rows, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.metadata_length, 2 * num_rows);\n }\n\n CU_ASSERT_EQUAL(table.num_rows, 2 * num_rows);\n\n /* Truncate back to num_rows */\n ret = tsk_edge_table_truncate(&table, num_rows);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.left, left, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.right, right, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parent, parent, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.child, child, num_rows * sizeof(tsk_id_t)), 0);\n if (options & TSK_TABLE_NO_METADATA) {\n CU_ASSERT_EQUAL(table.metadata, NULL);\n CU_ASSERT_EQUAL(table.metadata_offset, NULL);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n } else {\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.metadata_length, num_rows);\n }\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n\n ret = tsk_edge_table_truncate(&table, num_rows + 1);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_TABLE_POSITION);\n\n /* Test equality with and without metadata */\n tsk_edge_table_copy(&table, &table2, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_edge_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n if (!(options & TSK_TABLE_NO_METADATA)) {\n /* Change the metadata values */\n table2.metadata[0] = 0;\n CU_ASSERT_FALSE(tsk_edge_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_edge_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Change the last metadata entry */\n table2.metadata_offset[table2.num_rows]\n = table2.metadata_offset[table2.num_rows - 1];\n CU_ASSERT_FALSE(tsk_edge_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_edge_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Delete all metadata */\n tsk_memset(table2.metadata_offset, 0,\n (table2.num_rows + 1) * sizeof(*table2.metadata_offset));\n CU_ASSERT_FALSE(tsk_edge_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_edge_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n }\n tsk_edge_table_free(&table2);\n\n /* Inputs cannot be NULL */\n ret = tsk_edge_table_set_columns(\n &table, num_rows, NULL, right, parent, child, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_edge_table_set_columns(\n &table, num_rows, left, NULL, parent, child, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_edge_table_set_columns(\n &table, num_rows, left, right, NULL, child, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_edge_table_set_columns(\n &table, num_rows, left, right, parent, NULL, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_edge_table_set_columns(\n &table, num_rows, left, right, parent, child, NULL, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_edge_table_set_columns(\n &table, num_rows, left, right, parent, child, metadata, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* if metadata and metadata_offset are both null, all metadatas are zero length */\n num_rows = 10;\n tsk_memset(metadata_offset, 0, (num_rows + 1) * sizeof(tsk_size_t));\n ret = tsk_edge_table_set_columns(\n &table, num_rows, left, right, parent, child, NULL, NULL);\n CU_ASSERT_EQUAL(tsk_memcmp(table.left, left, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.right, right, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parent, parent, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.child, child, num_rows * sizeof(tsk_id_t)), 0);\n if (options & TSK_TABLE_NO_METADATA) {\n CU_ASSERT_EQUAL(table.metadata, NULL);\n CU_ASSERT_EQUAL(table.metadata_offset, NULL);\n } else {\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n }\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n ret = tsk_edge_table_append_columns(\n &table, num_rows, left, right, parent, child, NULL, NULL);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.left, left, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.left + num_rows, left, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.right, right, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.right + num_rows, right, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parent, parent, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.parent + num_rows, parent, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.child, child, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.child + num_rows, child, num_rows * sizeof(tsk_id_t)), 0);\n if (options & TSK_TABLE_NO_METADATA) {\n CU_ASSERT_EQUAL(table.metadata, NULL);\n CU_ASSERT_EQUAL(table.metadata_offset, NULL);\n } else {\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset + num_rows, metadata_offset,\n num_rows * sizeof(tsk_size_t)),\n 0);\n }\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n CU_ASSERT_EQUAL(table.num_rows, 2 * num_rows);\n tsk_edge_table_print_state(&table, _devnull);\n ret = tsk_edge_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Test extend method */\n ret = tsk_edge_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_init(&table2, options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Can't extend from self */\n ret = tsk_edge_table_extend(&table, &table, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n\n /* Two empty tables */\n CU_ASSERT_TRUE(tsk_edge_table_equals(&table, &table2, 0));\n ret = tsk_edge_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&table, &table2, 0));\n\n /* Row out of bounds */\n ret = tsk_edge_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n\n /* Num rows out of bounds */\n ret = tsk_edge_table_extend(&table, &table2, num_rows * 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n\n /* Copy rows in order if index NULL */\n if (options & TSK_TABLE_NO_METADATA) {\n ret = tsk_edge_table_set_columns(\n &table2, num_rows, left, right, parent, child, NULL, NULL);\n } else {\n ret = tsk_edge_table_set_columns(\n &table2, num_rows, left, right, parent, child, metadata, metadata_offset);\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_edge_table_equals(&table, &table2, 0));\n ret = tsk_edge_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&table, &table2, 0));\n\n /* Copy nothing if index not NULL but length zero */\n ret = tsk_edge_table_extend(&table, &table2, 0, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&table, &table2, 0));\n\n /* Copy first N rows in order if index NULL */\n ret = tsk_edge_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_extend(&table, &table2, num_rows / 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_truncate(&table2, num_rows / 2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&table, &table2, 0));\n if (options & TSK_TABLE_NO_METADATA) {\n ret = tsk_edge_table_set_columns(\n &table2, num_rows, left, right, parent, child, NULL, NULL);\n } else {\n ret = tsk_edge_table_set_columns(\n &table2, num_rows, left, right, parent, child, metadata, metadata_offset);\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Copy a subset */\n ret = tsk_edge_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_edge_table_equals(&table, &table2, 0));\n ret = tsk_edge_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < (tsk_id_t) num_row_subset; j++) {\n ret = tsk_edge_table_get_row(&table, j, &edge);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_get_row(&table2, row_subset[j], &edge2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(edge.parent, edge2.parent);\n CU_ASSERT_EQUAL(edge.child, edge2.child);\n CU_ASSERT_EQUAL(edge.left, edge2.left);\n CU_ASSERT_EQUAL(edge.right, edge2.right);\n CU_ASSERT_EQUAL(edge.metadata_length, edge2.metadata_length)\n CU_ASSERT_EQUAL(tsk_memcmp(edge.metadata, edge2.metadata,\n edge.metadata_length * sizeof(*edge.metadata)),\n 0);\n }\n\n ret = tsk_edge_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(table.metadata_schema_length, 0);\n CU_ASSERT_EQUAL(table.metadata_schema, NULL);\n const char *example = \"An example of metadata schema with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_length = (tsk_size_t) strlen(example);\n const char *example2 = \"A different example 🎄🌳🌴🌲🎋\";\n tsk_size_t example2_length = (tsk_size_t) strlen(example);\n ret = tsk_edge_table_set_metadata_schema(&table, example, example_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(table.metadata_schema_length, example_length);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_schema, example, example_length), 0);\n\n ret = tsk_edge_table_copy(&table, &table2, TSK_NO_INIT | options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(table.metadata_schema_length, table2.metadata_schema_length);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata_schema, table2.metadata_schema, example_length), 0);\n ret = tsk_edge_table_set_metadata_schema(&table2, example, example_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&table, &table2, 0));\n ret = tsk_edge_table_set_metadata_schema(&table2, example2, example2_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_edge_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_edge_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n\n ret = tsk_edge_table_clear(&table);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(table.num_rows, 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n ret = tsk_edge_table_free(&table);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_edge_table_free(&table2);\n CU_ASSERT_EQUAL(ret, 0);\n free(left);\n free(right);\n free(parent);\n free(child);\n free(metadata);\n free(metadata_offset);\n}\n\nstatic void\ntest_edge_table(void)\n{\n test_edge_table_with_options(0);\n test_edge_table_with_options(TSK_TABLE_NO_METADATA);\n}\n\nstatic void\ntest_edge_table_update_row(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_edge_table_t table;\n tsk_edge_t row;\n const char *metadata = \"ABC\";\n\n ret = tsk_edge_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_edge_table_add_row(&table, 0, 1.0, 2, 3, metadata, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&table, 1, 2.0, 3, 4, metadata, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&table, 2, 3.0, 4, 5, metadata, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_edge_table_update_row(&table, 0, 1, 2.0, 3, 4, &metadata[1], 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.left, 1);\n CU_ASSERT_EQUAL_FATAL(row.right, 2.0);\n CU_ASSERT_EQUAL_FATAL(row.parent, 3);\n CU_ASSERT_EQUAL_FATAL(row.child, 4);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_edge_table_update_row(&table, 0, row.left + 1, row.right + 1,\n row.parent + 1, row.child + 1, row.metadata, row.metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.left, 2);\n CU_ASSERT_EQUAL_FATAL(row.right, 3.0);\n CU_ASSERT_EQUAL_FATAL(row.parent, 4);\n CU_ASSERT_EQUAL_FATAL(row.child, 5);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_edge_table_update_row(&table, 0, 0, 0, 0, 0, metadata, 3);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.left, 0);\n CU_ASSERT_EQUAL_FATAL(row.right, 0);\n CU_ASSERT_EQUAL_FATAL(row.parent, 0);\n CU_ASSERT_EQUAL_FATAL(row.child, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.metadata[2], 'C');\n\n ret = tsk_edge_table_update_row(&table, 1, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_get_row(&table, 1, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.left, 0);\n CU_ASSERT_EQUAL_FATAL(row.right, 0);\n CU_ASSERT_EQUAL_FATAL(row.parent, 0);\n CU_ASSERT_EQUAL_FATAL(row.child, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 0);\n\n ret = tsk_edge_table_get_row(&table, 2, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.left, 2);\n CU_ASSERT_EQUAL_FATAL(row.right, 3.0);\n CU_ASSERT_EQUAL_FATAL(row.parent, 4);\n CU_ASSERT_EQUAL_FATAL(row.child, 5);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.metadata[2], 'C');\n\n ret = tsk_edge_table_update_row(&table, 3, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n\n tsk_edge_table_free(&table);\n}\n\nstatic void\ntest_edge_table_update_row_no_metadata(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_edge_table_t table;\n tsk_edge_t row;\n const char *metadata = \"ABC\";\n\n ret = tsk_edge_table_init(&table, TSK_TABLE_NO_METADATA);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_edge_table_add_row(&table, 0, 1.0, 2, 3, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&table, 1, 2.0, 3, 4, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&table, 2, 3.0, 4, 5, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_edge_table_update_row(&table, 0, 1, 2.0, 3, 4, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.left, 1);\n CU_ASSERT_EQUAL_FATAL(row.right, 2.0);\n CU_ASSERT_EQUAL_FATAL(row.parent, 3);\n CU_ASSERT_EQUAL_FATAL(row.child, 4);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 0);\n\n ret = tsk_edge_table_update_row(&table, 0, row.left + 1, row.right + 1,\n row.parent + 1, row.child + 1, row.metadata, row.metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.left, 2);\n CU_ASSERT_EQUAL_FATAL(row.right, 3.0);\n CU_ASSERT_EQUAL_FATAL(row.parent, 4);\n CU_ASSERT_EQUAL_FATAL(row.child, 5);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 0);\n\n ret = tsk_edge_table_update_row(&table, 1, 0, 0, 0, 0, metadata, 3);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_METADATA_DISABLED);\n\n tsk_edge_table_free(&table);\n}\n\nstatic void\ntest_edge_table_keep_rows(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_edge_table_t source, t1, t2;\n tsk_edge_t row;\n tsk_bool_t keep[3] = { 1, 1, 1 };\n tsk_id_t id_map[3];\n const char *metadata = \"ABC\";\n tsk_id_t indexes[] = { 0, 1, 2 };\n\n ret = tsk_edge_table_init(&source, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_edge_table_add_row(&source, 0, 1.0, 2, 3, metadata, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&source, 1, 2.0, 3, 4, metadata, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&source, 2, 3.0, 4, 5, metadata, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_edge_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_edge_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&t1, &source, 0));\n\n ret = tsk_edge_table_keep_rows(&t1, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&t1, &source, 0));\n CU_ASSERT_EQUAL_FATAL(id_map[0], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], 2);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n ret = tsk_edge_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_edge_table_copy(&source, &t1, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[0] = 0;\n keep[1] = 1;\n keep[2] = 0;\n ret = tsk_edge_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 1);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_edge_table_get_row(&t1, 0, &row);\n CU_ASSERT_EQUAL_FATAL(row.left, 1);\n CU_ASSERT_EQUAL_FATAL(row.right, 2.0);\n CU_ASSERT_EQUAL_FATAL(row.parent, 3);\n CU_ASSERT_EQUAL_FATAL(row.child, 4);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 2);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n\n tsk_edge_table_free(&t1);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n /* Keeping first n rows equivalent to truncate */\n for (j = 0; j < source.num_rows; j++) {\n ret = tsk_edge_table_copy(&source, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_truncate(&t1, j + 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[j] = 1;\n ret = tsk_edge_table_keep_rows(&t2, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&t1, &t2, 0));\n\n /* Adding the remaining rows back on to the table gives the original\n * table */\n ret = tsk_edge_table_extend(\n &t2, &source, source.num_rows - j - 1, indexes + j + 1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&source, &t2, 0));\n\n tsk_edge_table_free(&t1);\n tsk_edge_table_free(&t2);\n }\n\n tsk_edge_table_free(&source);\n}\n\nstatic void\ntest_edge_table_keep_rows_no_metadata(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_edge_table_t source, t1, t2;\n tsk_edge_t row;\n tsk_bool_t keep[3] = { 1, 1, 1 };\n tsk_id_t id_map[3];\n tsk_id_t indexes[] = { 0, 1, 2 };\n\n ret = tsk_edge_table_init(&source, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_edge_table_add_row(&source, 0, 1.0, 2, 3, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&source, 1, 2.0, 3, 4, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&source, 2, 3.0, 4, 5, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_edge_table_copy(&source, &t1, TSK_TABLE_NO_METADATA);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_edge_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&t1, &source, 0));\n\n ret = tsk_edge_table_keep_rows(&t1, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&t1, &source, 0));\n CU_ASSERT_EQUAL_FATAL(id_map[0], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], 2);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n ret = tsk_edge_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_edge_table_copy(&source, &t1, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[0] = 0;\n keep[1] = 1;\n keep[2] = 0;\n ret = tsk_edge_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 1);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_edge_table_get_row(&t1, 0, &row);\n CU_ASSERT_EQUAL_FATAL(row.left, 1);\n CU_ASSERT_EQUAL_FATAL(row.right, 2.0);\n CU_ASSERT_EQUAL_FATAL(row.parent, 3);\n CU_ASSERT_EQUAL_FATAL(row.child, 4);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 0);\n\n tsk_edge_table_free(&t1);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n /* Keeping first n rows equivalent to truncate */\n for (j = 0; j < source.num_rows; j++) {\n ret = tsk_edge_table_copy(&source, &t2, TSK_TABLE_NO_METADATA);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_copy(&source, &t1, TSK_TABLE_NO_METADATA);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_truncate(&t1, j + 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[j] = 1;\n ret = tsk_edge_table_keep_rows(&t2, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&t1, &t2, 0));\n\n /* Adding the remaining rows back on to the table gives the original\n * table */\n ret = tsk_edge_table_extend(\n &t2, &source, source.num_rows - j - 1, indexes + j + 1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&source, &t2, 0));\n\n tsk_edge_table_free(&t1);\n tsk_edge_table_free(&t2);\n }\n\n tsk_edge_table_free(&source);\n}\n\nstatic void\ntest_edge_table_takeset_with_options(tsk_flags_t table_options)\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_edge_table_t source_table, table;\n tsk_size_t num_rows = 100;\n tsk_id_t j;\n double *left;\n double *right;\n tsk_id_t *parent;\n tsk_id_t *child;\n char *metadata;\n tsk_size_t *metadata_offset;\n const char *test_metadata = \"test\";\n tsk_size_t test_metadata_length = 4;\n tsk_size_t zeros[num_rows + 1];\n tsk_id_t neg_ones[num_rows];\n\n tsk_memset(zeros, 0, (num_rows + 1) * sizeof(tsk_size_t));\n tsk_memset(neg_ones, 0xff, num_rows * sizeof(tsk_id_t));\n /* Make a table to copy from */\n ret = tsk_edge_table_init(&source_table, table_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n if (table_options & TSK_TABLE_NO_METADATA) {\n ret_id = tsk_edge_table_add_row(\n &source_table, (double) j, (double) j + 1, j + 2, j + 3, NULL, 0);\n\n } else {\n ret_id = tsk_edge_table_add_row(&source_table, (double) j, (double) j + 1,\n j + 2, j + 3, test_metadata, test_metadata_length);\n }\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n }\n\n /* Prepare arrays to be taken */\n left = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(left != NULL);\n tsk_memcpy(left, source_table.left, num_rows * sizeof(double));\n right = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(right != NULL);\n tsk_memcpy(right, source_table.right, num_rows * sizeof(double));\n parent = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(parent != NULL);\n tsk_memcpy(parent, source_table.parent, num_rows * sizeof(tsk_id_t));\n child = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(child != NULL);\n tsk_memcpy(child, source_table.child, num_rows * sizeof(tsk_id_t));\n if (table_options & TSK_TABLE_NO_METADATA) {\n metadata = NULL;\n metadata_offset = NULL;\n test_metadata = NULL;\n test_metadata_length = 0;\n } else {\n metadata = tsk_malloc(num_rows * test_metadata_length * sizeof(char));\n CU_ASSERT_FATAL(metadata != NULL);\n tsk_memcpy(metadata, source_table.metadata,\n num_rows * test_metadata_length * sizeof(char));\n metadata_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(metadata_offset != NULL);\n tsk_memcpy(metadata_offset, source_table.metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t));\n }\n\n ret = tsk_edge_table_init(&table, table_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Add one row so that we can check takeset frees it */\n ret_id = tsk_edge_table_add_row(\n &table, 1, 2, 3, 4, test_metadata, test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n ret = tsk_edge_table_takeset_columns(\n &table, num_rows, left, right, parent, child, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&source_table, &table, 0));\n\n /* Test error states, all of these must not take the array, or free existing */\n /* metadata and metadata offset must be simultaneously NULL or not */\n ret = tsk_edge_table_takeset_columns(\n &table, num_rows, NULL, right, parent, child, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_edge_table_takeset_columns(\n &table, num_rows, left, NULL, parent, child, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_edge_table_takeset_columns(\n &table, num_rows, left, right, NULL, child, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_edge_table_takeset_columns(\n &table, num_rows, left, right, parent, NULL, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n if (table_options & TSK_TABLE_NO_METADATA) {\n /* It isn't used, so any pointer does for testing that presence of metadata\n fails */\n ret = tsk_edge_table_takeset_columns(\n &table, num_rows, left, right, parent, child, (char *) child, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_METADATA_DISABLED);\n } else {\n ret = tsk_edge_table_takeset_columns(\n &table, num_rows, left, right, parent, child, NULL, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_edge_table_takeset_columns(\n &table, num_rows, left, right, parent, child, metadata, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n }\n\n /* Truncation after takeset keeps memory and max_rows */\n ret = tsk_edge_table_clear(&table);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(table.max_rows, num_rows);\n\n ret = tsk_edge_table_free(&table);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_edge_table_free(&source_table);\n CU_ASSERT_EQUAL(ret, 0);\n}\n\nstatic void\ntest_edge_table_takeset(void)\n{\n test_edge_table_takeset_with_options(TSK_TABLE_NO_METADATA);\n test_edge_table_takeset_with_options(0);\n}\n\nstatic void\ntest_edge_table_copy_semantics(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t t1, t2;\n tsk_edge_table_t edges;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n insert_edge_metadata(&t1);\n\n /* t1 now has metadata. We should be able to copy to another table with metadata */\n ret = tsk_table_collection_copy(&t1, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n tsk_table_collection_free(&t2);\n\n /* We should not be able to copy into a table with no metadata */\n ret = tsk_table_collection_copy(&t1, &t2, TSK_TC_NO_EDGE_METADATA);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_METADATA_DISABLED);\n tsk_table_collection_free(&t2);\n\n tsk_table_collection_free(&t1);\n ret = tsk_treeseq_copy_tables(&ts, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* t1 has no metadata, but metadata is enabled. We should be able to copy\n * into a table with either metadata enabled or disabled.\n */\n ret = tsk_table_collection_copy(&t1, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n tsk_table_collection_free(&t2);\n\n ret = tsk_table_collection_copy(&t1, &t2, TSK_TC_NO_EDGE_METADATA);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n tsk_table_collection_free(&t2);\n\n /* Try copying into a table directly */\n ret = tsk_edge_table_copy(&t1.edges, &edges, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&t1.edges, &edges, 0));\n tsk_edge_table_free(&edges);\n\n tsk_table_collection_free(&t1);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_edge_table_squash(void)\n{\n int ret;\n tsk_table_collection_t tables;\n\n const char *nodes_ex = \"1 0 -1 -1\\n\"\n \"1 0 -1 -1\\n\"\n \"0 0.253 -1 -1\\n\";\n const char *edges_ex = \"0 2 2 0\\n\"\n \"2 10 2 0\\n\"\n \"0 2 2 1\\n\"\n \"2 10 2 1\\n\";\n\n /*\n 2\n / \\\n 0 1\n */\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 10;\n\n parse_nodes(nodes_ex, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 3);\n parse_edges(edges_ex, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 4);\n\n ret = tsk_edge_table_squash(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // Check output.\n CU_ASSERT_EQUAL(tables.edges.num_rows, 2);\n\n // Free things.\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_edge_table_squash_multiple_parents(void)\n{\n int ret;\n tsk_table_collection_t tables;\n\n const char *nodes_ex = \"1 0.000 -1 -1\\n\"\n \"1 0.000 -1 -1\\n\"\n \"1 0.000 -1 -1\\n\"\n \"1 0.000 -1 -1\\n\"\n \"0 1.000 -1 -1\\n\"\n \"0 1.000 -1 -1\\n\";\n const char *edges_ex = \"5 10 5 3\\n\"\n \"5 10 5 2\\n\"\n \"0 5 5 3\\n\"\n \"0 5 5 2\\n\"\n \"4 10 4 1\\n\"\n \"0 4 4 1\\n\"\n \"4 10 4 0\\n\"\n \"0 4 4 0\\n\";\n /*\n 4 5\n / \\ / \\\n 0 1 2 3\n */\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 10;\n\n parse_nodes(nodes_ex, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 6);\n parse_edges(edges_ex, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 8);\n\n ret = tsk_edge_table_squash(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // Check output.\n CU_ASSERT_EQUAL(tables.edges.num_rows, 4);\n\n // Free things.\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_edge_table_squash_empty(void)\n{\n int ret;\n tsk_table_collection_t tables;\n\n const char *nodes_ex = \"1 0 -1 -1\\n\"\n \"1 0 -1 -1\\n\"\n \"0 0.253 -1 -1\\n\";\n const char *edges_ex = \"\";\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 10;\n\n parse_nodes(nodes_ex, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 3);\n parse_edges(edges_ex, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 0);\n\n ret = tsk_edge_table_squash(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // Free things.\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_edge_table_squash_single_edge(void)\n{\n int ret;\n tsk_table_collection_t tables;\n\n const char *nodes_ex = \"1 0 -1 -1\\n\"\n \"0 0 -1 -1\\n\";\n const char *edges_ex = \"0 1 1 0\\n\";\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n parse_nodes(nodes_ex, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 2);\n parse_edges(edges_ex, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 1);\n\n ret = tsk_edge_table_squash(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // Free things.\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_edge_table_squash_bad_intervals(void)\n{\n int ret;\n tsk_table_collection_t tables;\n\n const char *nodes_ex = \"1 0 -1 -1\\n\"\n \"0 0 -1 -1\\n\";\n const char *edges_ex = \"0 0.6 1 0\\n\"\n \"0.4 1 1 0\\n\";\n\n ret = tsk_table_collection_init(&tables, TSK_TC_NO_EDGE_METADATA);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n parse_nodes(nodes_ex, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 2);\n parse_edges(edges_ex, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 2);\n\n ret = tsk_edge_table_squash(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_EDGES_CONTRADICTORY_CHILDREN);\n\n // Free things.\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_edge_table_squash_metadata(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 10;\n ret_id = tsk_edge_table_add_row(&tables.edges, 0, 0, 1, 1, \"metadata\", 8);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n ret = tsk_edge_table_squash(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_CANT_PROCESS_EDGES_WITH_METADATA);\n\n tsk_table_collection_free(&tables);\n\n ret = tsk_table_collection_init(&tables, TSK_TC_NO_EDGE_METADATA);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 10;\n ret_id = tsk_edge_table_add_row(&tables.edges, 0, 0, 1, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n ret = tsk_edge_table_squash(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_site_table(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_site_table_t table, table2;\n tsk_size_t num_rows, j;\n char *ancestral_state;\n char *metadata;\n double *position;\n tsk_site_t site, site2;\n tsk_size_t *ancestral_state_offset;\n tsk_size_t *metadata_offset;\n tsk_id_t row_subset[6] = { 1, 9, 1, 0, 2, 2 };\n tsk_size_t num_row_subset = 6;\n\n ret = tsk_site_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_site_table_set_max_rows_increment(&table, 1);\n tsk_site_table_set_max_metadata_length_increment(&table, 1);\n tsk_site_table_set_max_ancestral_state_length_increment(&table, 1);\n tsk_site_table_print_state(&table, _devnull);\n ret = tsk_site_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_site_table_add_row(&table, 0, \"A\", 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n CU_ASSERT_EQUAL(table.position[0], 0);\n CU_ASSERT_EQUAL(table.ancestral_state_offset[0], 0);\n CU_ASSERT_EQUAL(table.ancestral_state_offset[1], 1);\n CU_ASSERT_EQUAL(table.ancestral_state_length, 1);\n CU_ASSERT_EQUAL(table.metadata_offset[0], 0);\n CU_ASSERT_EQUAL(table.metadata_offset[1], 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n CU_ASSERT_EQUAL(table.num_rows, 1);\n\n ret = tsk_site_table_get_row(&table, 0, &site);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(site.position, 0);\n CU_ASSERT_EQUAL(site.ancestral_state_length, 1);\n CU_ASSERT_NSTRING_EQUAL(site.ancestral_state, \"A\", 1);\n CU_ASSERT_EQUAL(site.metadata_length, 0);\n\n ret_id = tsk_site_table_add_row(&table, 1, \"AA\", 2, \"{}\", 2);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n CU_ASSERT_EQUAL(table.position[1], 1);\n CU_ASSERT_EQUAL(table.ancestral_state_offset[2], 3);\n CU_ASSERT_EQUAL(table.metadata_offset[1], 0);\n CU_ASSERT_EQUAL(table.metadata_offset[2], 2);\n CU_ASSERT_EQUAL(table.metadata_length, 2);\n CU_ASSERT_EQUAL(table.num_rows, 2);\n\n ret = tsk_site_table_get_row(&table, 1, &site);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(site.position, 1);\n CU_ASSERT_EQUAL(site.ancestral_state_length, 2);\n CU_ASSERT_NSTRING_EQUAL(site.ancestral_state, \"AA\", 2);\n CU_ASSERT_EQUAL(site.metadata_length, 2);\n CU_ASSERT_NSTRING_EQUAL(site.metadata, \"{}\", 2);\n\n ret_id = tsk_site_table_add_row(&table, 2, \"A\", 1, \"metadata\", 8);\n CU_ASSERT_EQUAL_FATAL(ret_id, 2);\n CU_ASSERT_EQUAL(table.position[1], 1);\n CU_ASSERT_EQUAL(table.ancestral_state_offset[3], 4);\n CU_ASSERT_EQUAL(table.ancestral_state_length, 4);\n CU_ASSERT_EQUAL(table.metadata_offset[3], 10);\n CU_ASSERT_EQUAL(table.metadata_length, 10);\n CU_ASSERT_EQUAL(table.num_rows, 3);\n\n ret = tsk_site_table_get_row(&table, 3, &site);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n\n tsk_site_table_print_state(&table, _devnull);\n ret = tsk_site_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_site_table_clear(&table);\n CU_ASSERT_EQUAL(table.num_rows, 0);\n CU_ASSERT_EQUAL(table.ancestral_state_length, 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n CU_ASSERT_EQUAL(table.ancestral_state_offset[0], 0);\n CU_ASSERT_EQUAL(table.metadata_offset[0], 0);\n\n num_rows = 100;\n position = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(position != NULL);\n ancestral_state = tsk_malloc(num_rows * sizeof(char));\n CU_ASSERT_FATAL(ancestral_state != NULL);\n ancestral_state_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(ancestral_state_offset != NULL);\n metadata = tsk_malloc(num_rows * sizeof(char));\n CU_ASSERT_FATAL(metadata != NULL);\n metadata_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(metadata_offset != NULL);\n\n for (j = 0; j < num_rows; j++) {\n position[j] = (double) j;\n ancestral_state[j] = (char) j;\n ancestral_state_offset[j] = (tsk_size_t) j;\n metadata[j] = (char) ('A' + j);\n metadata_offset[j] = (tsk_size_t) j;\n }\n ancestral_state_offset[num_rows] = num_rows;\n metadata_offset[num_rows] = num_rows;\n\n ret = tsk_site_table_set_columns(&table, num_rows, position, ancestral_state,\n ancestral_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.position, position, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.ancestral_state, ancestral_state, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.ancestral_state_length, num_rows);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.metadata_length, num_rows);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n\n /* Append another num rows */\n ret = tsk_site_table_append_columns(&table, num_rows, position, ancestral_state,\n ancestral_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.position, position, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.position + num_rows, position, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.ancestral_state, ancestral_state, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.ancestral_state + num_rows, ancestral_state,\n num_rows * sizeof(char)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata + num_rows, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.num_rows, 2 * num_rows);\n CU_ASSERT_EQUAL(table.ancestral_state_length, 2 * num_rows);\n\n /* truncate back to num_rows */\n ret = tsk_site_table_truncate(&table, num_rows);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.position, position, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.ancestral_state, ancestral_state, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.ancestral_state_length, num_rows);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.metadata_length, num_rows);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n\n ret = tsk_site_table_truncate(&table, num_rows + 1);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_TABLE_POSITION);\n\n /* Test equality with and without metadata */\n tsk_site_table_copy(&table, &table2, 0);\n CU_ASSERT_TRUE(tsk_site_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_site_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Change the metadata values */\n table2.metadata[0] = 0;\n CU_ASSERT_FALSE(tsk_site_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_site_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Change the last metadata entry */\n table2.metadata_offset[table2.num_rows]\n = table2.metadata_offset[table2.num_rows - 1];\n CU_ASSERT_FALSE(tsk_site_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_site_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Delete all metadata */\n tsk_memset(table2.metadata_offset, 0,\n (table2.num_rows + 1) * sizeof(*table2.metadata_offset));\n CU_ASSERT_FALSE(tsk_site_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_site_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n tsk_site_table_free(&table2);\n\n /* Inputs cannot be NULL */\n ret = tsk_site_table_set_columns(&table, num_rows, NULL, ancestral_state,\n ancestral_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_site_table_set_columns(&table, num_rows, position, NULL,\n ancestral_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_site_table_set_columns(\n &table, num_rows, position, ancestral_state, NULL, metadata, metadata_offset);\n /* Metadata and metadata_offset must both be null */\n ret = tsk_site_table_set_columns(&table, num_rows, position, ancestral_state,\n ancestral_state_offset, NULL, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_site_table_set_columns(&table, num_rows, position, ancestral_state,\n ancestral_state_offset, metadata, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* Set metadata to NULL */\n ret = tsk_site_table_set_columns(\n &table, num_rows, position, ancestral_state, ancestral_state_offset, NULL, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_memset(metadata_offset, 0, (num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_EQUAL(tsk_memcmp(table.position, position, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.ancestral_state, ancestral_state, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.ancestral_state_length, num_rows);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n\n /* Test extend method */\n ret = tsk_site_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_site_table_init(&table2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Can't extend from self */\n ret = tsk_site_table_extend(&table, &table, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n\n /* Two empty tables */\n CU_ASSERT_TRUE(tsk_site_table_equals(&table, &table2, 0));\n ret = tsk_site_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_site_table_equals(&table, &table2, 0));\n\n /* Row out of bounds */\n ret = tsk_site_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n\n /* Num rows out of bounds */\n ret = tsk_site_table_extend(&table, &table2, num_rows * 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n\n /* Copy rows in order if index NULL */\n ret = tsk_site_table_set_columns(&table2, num_rows, position, ancestral_state,\n ancestral_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_site_table_equals(&table, &table2, 0));\n ret = tsk_site_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_site_table_equals(&table, &table2, 0));\n\n /* Copy nothing if index not NULL but length zero */\n ret = tsk_site_table_extend(&table, &table2, 0, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_site_table_equals(&table, &table2, 0));\n\n /* Copy first N rows in order if index NULL */\n ret = tsk_site_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_site_table_extend(&table, &table2, num_rows / 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_site_table_truncate(&table2, num_rows / 2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_site_table_equals(&table, &table2, 0));\n ret = tsk_site_table_set_columns(&table2, num_rows, position, ancestral_state,\n ancestral_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Copy a subset */\n ret = tsk_site_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_site_table_equals(&table, &table2, 0));\n ret = tsk_site_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < num_row_subset; j++) {\n ret = tsk_site_table_get_row(&table, (tsk_id_t) j, &site);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_site_table_get_row(&table2, row_subset[j], &site2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(site.position, site2.position);\n CU_ASSERT_EQUAL(site.ancestral_state_length, site2.ancestral_state_length);\n CU_ASSERT_EQUAL(site.metadata_length, site2.metadata_length);\n CU_ASSERT_EQUAL(tsk_memcmp(site.ancestral_state, site2.ancestral_state,\n site.ancestral_state_length * sizeof(*site.ancestral_state)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(site.metadata, site2.metadata,\n site.metadata_length * sizeof(*site.metadata)),\n 0);\n }\n\n /* Test for bad offsets */\n ancestral_state_offset[0] = 1;\n ret = tsk_site_table_set_columns(&table, num_rows, position, ancestral_state,\n ancestral_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n ancestral_state_offset[0] = 0;\n ancestral_state_offset[num_rows] = 0;\n ret = tsk_site_table_set_columns(&table, num_rows, position, ancestral_state,\n ancestral_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n ancestral_state_offset[0] = 0;\n\n metadata_offset[0] = 0;\n ret = tsk_site_table_set_columns(&table, num_rows, position, ancestral_state,\n ancestral_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n metadata_offset[0] = 0;\n metadata_offset[num_rows] = 0;\n ret = tsk_site_table_set_columns(&table, num_rows, position, ancestral_state,\n ancestral_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n ret = tsk_site_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(table.metadata_schema_length, 0);\n CU_ASSERT_EQUAL(table.metadata_schema, NULL);\n const char *example = \"An example of metadata schema with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_length = (tsk_size_t) strlen(example);\n const char *example2 = \"A different example 🎄🌳🌴🌲🎋\";\n tsk_size_t example2_length = (tsk_size_t) strlen(example);\n tsk_site_table_set_metadata_schema(&table, example, example_length);\n CU_ASSERT_EQUAL(table.metadata_schema_length, example_length);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_schema, example, example_length), 0);\n\n tsk_site_table_copy(&table, &table2, TSK_NO_INIT);\n CU_ASSERT_EQUAL(table.metadata_schema_length, table2.metadata_schema_length);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata_schema, table2.metadata_schema, example_length), 0);\n tsk_site_table_set_metadata_schema(&table2, example, example_length);\n CU_ASSERT_TRUE(tsk_site_table_equals(&table, &table2, 0));\n tsk_site_table_set_metadata_schema(&table2, example2, example2_length);\n CU_ASSERT_FALSE(tsk_site_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_site_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n\n ret = tsk_site_table_clear(&table);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(table.num_rows, 0);\n CU_ASSERT_EQUAL(table.ancestral_state_length, 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n tsk_site_table_free(&table);\n CU_ASSERT_EQUAL(ret, 0);\n tsk_site_table_free(&table2);\n CU_ASSERT_EQUAL(ret, 0);\n\n free(position);\n free(ancestral_state);\n free(ancestral_state_offset);\n free(metadata);\n free(metadata_offset);\n}\n\nstatic void\ntest_site_table_takeset(void)\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_site_table_t source_table, table;\n tsk_size_t num_rows = 100;\n tsk_id_t j;\n double *position;\n char *ancestral_state;\n tsk_size_t *ancestral_state_offset;\n char *metadata;\n tsk_size_t *metadata_offset;\n const char *test_ancestral_state = \"red\";\n tsk_size_t test_ancestral_state_length = 3;\n const char *test_metadata = \"test\";\n tsk_size_t test_metadata_length = 4;\n tsk_size_t zeros[num_rows + 1];\n tsk_id_t neg_ones[num_rows];\n\n tsk_memset(zeros, 0, (num_rows + 1) * sizeof(tsk_size_t));\n tsk_memset(neg_ones, 0xff, num_rows * sizeof(tsk_id_t));\n /* Make a table to copy from */\n ret = tsk_site_table_init(&source_table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n ret_id = tsk_site_table_add_row(&source_table, (double) j, test_ancestral_state,\n test_ancestral_state_length, test_metadata, test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n }\n\n /* Prepare arrays to be taken */\n position = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(position != NULL);\n tsk_memcpy(position, source_table.position, num_rows * sizeof(double));\n ancestral_state = tsk_malloc(num_rows * test_ancestral_state_length * sizeof(char));\n CU_ASSERT_FATAL(ancestral_state != NULL);\n tsk_memcpy(ancestral_state, source_table.ancestral_state,\n num_rows * test_ancestral_state_length * sizeof(char));\n ancestral_state_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(ancestral_state_offset != NULL);\n tsk_memcpy(ancestral_state_offset, source_table.ancestral_state_offset,\n (num_rows + 1) * sizeof(tsk_size_t));\n metadata = tsk_malloc(num_rows * test_metadata_length * sizeof(char));\n CU_ASSERT_FATAL(metadata != NULL);\n tsk_memcpy(\n metadata, source_table.metadata, num_rows * test_metadata_length * sizeof(char));\n metadata_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(metadata_offset != NULL);\n tsk_memcpy(metadata_offset, source_table.metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t));\n\n ret = tsk_site_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Add one row so that we can check takeset frees it */\n ret_id = tsk_site_table_add_row(&table, 1, test_ancestral_state,\n test_ancestral_state_length, test_metadata, test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n ret = tsk_site_table_takeset_columns(&table, num_rows, position, ancestral_state,\n ancestral_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_site_table_equals(&source_table, &table, 0));\n\n /* Test error states, all of these must not take the array, or free existing */\n /* metadata and metadata offset must be simultaneously NULL or not */\n ret = tsk_site_table_takeset_columns(&table, num_rows, NULL, ancestral_state,\n ancestral_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_site_table_takeset_columns(&table, num_rows, position, NULL,\n ancestral_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_site_table_takeset_columns(\n &table, num_rows, position, ancestral_state, NULL, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_site_table_takeset_columns(&table, num_rows, position, ancestral_state,\n ancestral_state_offset, NULL, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_site_table_takeset_columns(&table, num_rows, position, ancestral_state,\n ancestral_state_offset, metadata, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n /* Check bad offset in ancestral_state */\n ancestral_state_offset[0] = 1;\n ret = tsk_site_table_takeset_columns(&table, num_rows, position, ancestral_state,\n ancestral_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n\n /* Truncation after takeset keeps memory and max_rows */\n ret = tsk_site_table_clear(&table);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(table.max_rows, num_rows);\n\n position = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(position != NULL);\n tsk_memcpy(position, source_table.position, num_rows * sizeof(double));\n ancestral_state = tsk_malloc(num_rows * test_ancestral_state_length * sizeof(char));\n CU_ASSERT_FATAL(ancestral_state != NULL);\n tsk_memcpy(ancestral_state, source_table.ancestral_state,\n num_rows * test_ancestral_state_length * sizeof(char));\n ancestral_state_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(ancestral_state_offset != NULL);\n tsk_memcpy(ancestral_state_offset, source_table.ancestral_state_offset,\n (num_rows + 1) * sizeof(tsk_size_t));\n /* if metadata and offset are both null, all entries are zero length*/\n num_rows = 10;\n ret = tsk_site_table_takeset_columns(\n &table, num_rows, position, ancestral_state, ancestral_state_offset, NULL, NULL);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata_offset, zeros, (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n ret = tsk_site_table_free(&table);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_site_table_free(&source_table);\n CU_ASSERT_EQUAL(ret, 0);\n}\n\nstatic void\ntest_site_table_update_row(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_site_table_t table;\n tsk_site_t row;\n const char *ancestral_state = \"XYZ\";\n const char *metadata = \"ABC\";\n\n ret = tsk_site_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_site_table_add_row(&table, 0, ancestral_state, 1, metadata, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&table, 1, ancestral_state, 2, metadata, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&table, 2, ancestral_state, 3, metadata, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_site_table_update_row(\n &table, 0, 1, &ancestral_state[1], 1, &metadata[1], 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_site_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.position, 1);\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state[0], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_site_table_update_row(&table, 0, row.position + 1, row.ancestral_state,\n row.ancestral_state_length, row.metadata, row.metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_site_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.position, 2);\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state[0], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_site_table_update_row(&table, 0, row.position, row.ancestral_state,\n row.ancestral_state_length, row.metadata, row.metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_site_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.position, 2);\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state[0], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_site_table_update_row(\n &table, 0, row.position, NULL, 0, row.metadata, row.metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_site_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.position, 2);\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state_length, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_site_table_update_row(&table, 0, 2, ancestral_state, 3, metadata, 3);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_site_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.position, 2);\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state[0], 'X');\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state[1], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state[2], 'Z');\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.metadata[2], 'C');\n\n ret = tsk_site_table_update_row(&table, 1, 5, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_site_table_get_row(&table, 1, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.position, 5);\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state_length, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 0);\n\n ret = tsk_site_table_get_row(&table, 2, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.position, 2);\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state[0], 'X');\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state[1], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state[2], 'Z');\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.metadata[2], 'C');\n\n ret = tsk_site_table_update_row(&table, 3, 0, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n\n tsk_site_table_free(&table);\n}\n\nstatic void\ntest_site_table_keep_rows(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_site_table_t source, t1, t2;\n tsk_site_t row;\n const char *ancestral_state = \"XYZ\";\n const char *metadata = \"ABC\";\n tsk_bool_t keep[3] = { 1, 1, 1 };\n tsk_id_t id_map[3];\n tsk_id_t indexes[] = { 0, 1, 2 };\n\n ret = tsk_site_table_init(&source, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_site_table_add_row(&source, 0, ancestral_state, 1, metadata, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&source, 1, ancestral_state, 2, metadata, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&source, 2, ancestral_state, 3, metadata, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_site_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_site_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_site_table_equals(&t1, &source, 0));\n\n ret = tsk_site_table_keep_rows(&t1, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_site_table_equals(&t1, &source, 0));\n CU_ASSERT_EQUAL_FATAL(id_map[0], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], 2);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n ret = tsk_site_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_site_table_copy(&source, &t1, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[0] = 0;\n keep[1] = 1;\n keep[2] = 0;\n ret = tsk_site_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 1);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_site_table_get_row(&t1, 0, &row);\n CU_ASSERT_EQUAL_FATAL(row.position, 1);\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state_length, 2);\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state[0], 'X');\n CU_ASSERT_EQUAL_FATAL(row.ancestral_state[1], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 2);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n\n tsk_site_table_free(&t1);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n /* Keeping first n rows equivalent to truncate */\n for (j = 0; j < source.num_rows; j++) {\n ret = tsk_site_table_copy(&source, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_site_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_site_table_truncate(&t1, j + 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[j] = 1;\n ret = tsk_site_table_keep_rows(&t2, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_site_table_equals(&t1, &t2, 0));\n\n /* Adding the remaining rows back on to the table gives the original\n * table */\n ret = tsk_site_table_extend(\n &t2, &source, source.num_rows - j - 1, indexes + j + 1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_site_table_equals(&source, &t2, 0));\n\n tsk_site_table_free(&t1);\n tsk_site_table_free(&t2);\n }\n\n tsk_site_table_free(&source);\n}\n\nstatic void\ntest_mutation_table(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_mutation_table_t table, table2;\n tsk_size_t num_rows = 100;\n tsk_size_t max_len = 20;\n tsk_size_t k, len;\n tsk_id_t j;\n tsk_id_t *node;\n tsk_id_t *parent;\n tsk_id_t *site;\n double *time;\n char *derived_state, *metadata;\n char c[max_len + 1];\n tsk_size_t *derived_state_offset, *metadata_offset;\n tsk_mutation_t mutation, mutation2;\n tsk_id_t row_subset[6] = { 1, 9, 1, 0, 2, 2 };\n tsk_size_t num_row_subset = 6;\n\n for (j = 0; j < (tsk_id_t) max_len; j++) {\n c[j] = (char) ('A' + j);\n }\n\n ret = tsk_mutation_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_mutation_table_set_max_rows_increment(&table, 1);\n tsk_mutation_table_set_max_metadata_length_increment(&table, 1);\n tsk_mutation_table_set_max_derived_state_length_increment(&table, 1);\n tsk_mutation_table_print_state(&table, _devnull);\n ret = tsk_mutation_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n len = 0;\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n k = TSK_MIN((tsk_size_t) j + 1, max_len);\n ret_id = tsk_mutation_table_add_row(&table, j, j, j, (double) j, c, k, c, k);\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n CU_ASSERT_EQUAL(table.site[j], j);\n CU_ASSERT_EQUAL(table.node[j], j);\n CU_ASSERT_EQUAL(table.parent[j], j);\n CU_ASSERT_EQUAL(table.time[j], j);\n CU_ASSERT_EQUAL(table.derived_state_offset[j], len);\n CU_ASSERT_EQUAL(table.metadata_offset[j], len);\n CU_ASSERT_EQUAL(table.num_rows, (tsk_size_t) j + 1);\n len += k;\n CU_ASSERT_EQUAL(table.derived_state_offset[j + 1], len);\n CU_ASSERT_EQUAL(table.derived_state_length, len);\n CU_ASSERT_EQUAL(table.metadata_offset[j + 1], len);\n CU_ASSERT_EQUAL(table.metadata_length, len);\n\n ret = tsk_mutation_table_get_row(&table, (tsk_id_t) j, &mutation);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(mutation.id, j);\n CU_ASSERT_EQUAL(mutation.site, j);\n CU_ASSERT_EQUAL(mutation.node, j);\n CU_ASSERT_EQUAL(mutation.parent, j);\n CU_ASSERT_EQUAL(mutation.time, j);\n CU_ASSERT_EQUAL(mutation.metadata_length, k);\n CU_ASSERT_NSTRING_EQUAL(mutation.metadata, c, k);\n CU_ASSERT_EQUAL(mutation.derived_state_length, k);\n CU_ASSERT_NSTRING_EQUAL(mutation.derived_state, c, k);\n }\n ret = tsk_mutation_table_get_row(&table, (tsk_id_t) num_rows, &mutation);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n tsk_mutation_table_print_state(&table, _devnull);\n ret = tsk_mutation_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n num_rows *= 2;\n site = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(site != NULL);\n node = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(node != NULL);\n parent = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(parent != NULL);\n time = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(time != NULL);\n derived_state = tsk_malloc(num_rows * sizeof(char));\n CU_ASSERT_FATAL(derived_state != NULL);\n derived_state_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(derived_state_offset != NULL);\n metadata = tsk_malloc(num_rows * sizeof(char));\n CU_ASSERT_FATAL(metadata != NULL);\n metadata_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(metadata_offset != NULL);\n\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n node[j] = j;\n site[j] = j + 1;\n parent[j] = j + 2;\n time[j] = (double) (j + 3);\n derived_state[j] = 'Y';\n derived_state_offset[j] = (tsk_size_t) j;\n metadata[j] = 'M';\n metadata_offset[j] = (tsk_size_t) j;\n }\n\n derived_state_offset[num_rows] = num_rows;\n metadata_offset[num_rows] = num_rows;\n ret = tsk_mutation_table_set_columns(&table, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.site, site, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.node, node, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parent, parent, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.derived_state, derived_state, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.derived_state_length, num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, num_rows);\n\n /* Append another num_rows */\n ret = tsk_mutation_table_append_columns(&table, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.site, site, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.site + num_rows, site, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.node, node, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.node + num_rows, node, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parent, parent, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.parent + num_rows, parent, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.time + num_rows, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.derived_state, derived_state, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.derived_state, derived_state, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.derived_state_length, 2 * num_rows);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.metadata_length, 2 * num_rows);\n CU_ASSERT_EQUAL(table.num_rows, 2 * num_rows);\n\n /* Truncate back to num_rows */\n ret = tsk_mutation_table_truncate(&table, num_rows);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.site, site, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.node, node, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parent, parent, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.derived_state, derived_state, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.derived_state_length, num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, num_rows);\n\n /* Test equality with and without metadata */\n tsk_mutation_table_copy(&table, &table2, 0);\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Change the metadata values */\n table2.metadata[0] = 0;\n CU_ASSERT_FALSE(tsk_mutation_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Change the last metadata entry */\n table2.metadata_offset[table2.num_rows]\n = table2.metadata_offset[table2.num_rows - 1];\n CU_ASSERT_FALSE(tsk_mutation_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Delete all metadata */\n tsk_memset(table2.metadata_offset, 0,\n (table2.num_rows + 1) * sizeof(*table2.metadata_offset));\n CU_ASSERT_FALSE(tsk_mutation_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n tsk_mutation_table_free(&table2);\n\n ret = tsk_mutation_table_truncate(&table, num_rows + 1);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_TABLE_POSITION);\n\n /* Check all this again, except with parent == NULL, time == NULL\n * and metadata == NULL. */\n tsk_memset(parent, 0xff, num_rows * sizeof(tsk_id_t));\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n time[j] = TSK_UNKNOWN_TIME;\n }\n tsk_memset(metadata_offset, 0, (num_rows + 1) * sizeof(tsk_size_t));\n ret = tsk_mutation_table_set_columns(&table, num_rows, site, node, NULL, NULL,\n derived_state, derived_state_offset, NULL, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.site, site, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.node, node, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parent, parent, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.derived_state, derived_state, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.derived_state_offset, derived_state_offset,\n num_rows * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.derived_state_length, num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n /* Append another num_rows */\n ret = tsk_mutation_table_append_columns(&table, num_rows, site, node, NULL, NULL,\n derived_state, derived_state_offset, NULL, NULL);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.site, site, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.site + num_rows, site, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.node, node, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.node + num_rows, node, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parent, parent, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.parent + num_rows, parent, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.time + num_rows, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.derived_state, derived_state, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.derived_state + num_rows, derived_state,\n num_rows * sizeof(char)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, 2 * num_rows);\n CU_ASSERT_EQUAL(table.derived_state_length, 2 * num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n /* Inputs except parent, time, metadata and metadata_offset cannot be NULL*/\n ret = tsk_mutation_table_set_columns(&table, num_rows, NULL, node, parent, time,\n derived_state, derived_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_mutation_table_set_columns(&table, num_rows, site, NULL, parent, time,\n derived_state, derived_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_mutation_table_set_columns(&table, num_rows, site, node, parent, time,\n NULL, derived_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_mutation_table_set_columns(&table, num_rows, site, node, parent, time,\n derived_state, NULL, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_mutation_table_set_columns(&table, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, NULL, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_mutation_table_set_columns(&table, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, metadata, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* Inputs except parent, time, metadata and metadata_offset cannot be NULL*/\n ret = tsk_mutation_table_append_columns(&table, num_rows, NULL, node, parent, time,\n derived_state, derived_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_mutation_table_append_columns(&table, num_rows, site, NULL, parent, time,\n derived_state, derived_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_mutation_table_append_columns(&table, num_rows, site, node, parent, time,\n NULL, derived_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_mutation_table_append_columns(&table, num_rows, site, node, parent, time,\n derived_state, NULL, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_mutation_table_append_columns(&table, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, NULL, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_mutation_table_append_columns(&table, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, metadata, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* Test extend method */\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n parent[j] = j + 2;\n time[j] = (double) (j + 3);\n metadata[j] = (char) ('A' + j);\n metadata_offset[j] = (tsk_size_t) j;\n }\n metadata_offset[num_rows] = num_rows;\n ret = tsk_mutation_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_mutation_table_init(&table2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Can't extend from self */\n ret = tsk_mutation_table_extend(&table, &table, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n\n /* Two empty tables */\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&table, &table2, 0));\n ret = tsk_mutation_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&table, &table2, 0));\n\n /* Row out of bounds */\n ret = tsk_mutation_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n\n /* Num rows out of bounds */\n ret = tsk_mutation_table_extend(&table, &table2, num_rows * 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n\n /* Copy rows in order if index NULL */\n ret = tsk_mutation_table_set_columns(&table2, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_mutation_table_equals(&table, &table2, 0));\n ret = tsk_mutation_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&table, &table2, 0));\n\n /* Copy nothing if index not NULL but length zero */\n ret = tsk_mutation_table_extend(&table, &table2, 0, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&table, &table2, 0));\n\n /* Copy first N rows in order if index NULL */\n ret = tsk_mutation_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_mutation_table_extend(&table, &table2, num_rows / 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_mutation_table_truncate(&table2, num_rows / 2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&table, &table2, 0));\n ret = tsk_mutation_table_set_columns(&table2, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Copy a subset */\n ret = tsk_mutation_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_mutation_table_equals(&table, &table2, 0));\n ret = tsk_mutation_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (k = 0; k < num_row_subset; k++) {\n ret = tsk_mutation_table_get_row(&table, (tsk_id_t) k, &mutation);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_mutation_table_get_row(&table2, row_subset[k], &mutation2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(mutation.site, mutation2.site);\n CU_ASSERT_EQUAL(mutation.node, mutation2.node);\n CU_ASSERT_EQUAL(mutation.parent, mutation2.parent);\n CU_ASSERT_EQUAL(mutation.time, mutation2.time);\n CU_ASSERT_EQUAL(mutation.derived_state_length, mutation2.derived_state_length);\n CU_ASSERT_EQUAL(mutation.metadata_length, mutation2.metadata_length);\n CU_ASSERT_EQUAL(\n tsk_memcmp(mutation.derived_state, mutation2.derived_state,\n mutation.derived_state_length * sizeof(*mutation.derived_state)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(mutation.metadata, mutation2.metadata,\n mutation.metadata_length * sizeof(*mutation.metadata)),\n 0);\n }\n\n /* Test for bad offsets */\n derived_state_offset[0] = 1;\n ret = tsk_mutation_table_set_columns(&table, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, NULL, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n derived_state_offset[0] = 0;\n derived_state_offset[num_rows] = 0;\n ret = tsk_mutation_table_set_columns(&table, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, NULL, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n\n ret = tsk_mutation_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(table.metadata_schema_length, 0);\n CU_ASSERT_EQUAL(table.metadata_schema, NULL);\n const char *example = \"An example of metadata schema with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_length = (tsk_size_t) strlen(example);\n const char *example2 = \"A different example 🎄🌳🌴🌲🎋\";\n tsk_size_t example2_length = (tsk_size_t) strlen(example);\n tsk_mutation_table_set_metadata_schema(&table, example, example_length);\n CU_ASSERT_EQUAL(table.metadata_schema_length, example_length);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_schema, example, example_length), 0);\n\n tsk_mutation_table_copy(&table, &table2, TSK_NO_INIT);\n CU_ASSERT_EQUAL(table.metadata_schema_length, table2.metadata_schema_length);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata_schema, table2.metadata_schema, example_length), 0);\n tsk_mutation_table_set_metadata_schema(&table2, example, example_length);\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&table, &table2, 0));\n tsk_mutation_table_set_metadata_schema(&table2, example2, example2_length);\n CU_ASSERT_FALSE(tsk_mutation_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n\n tsk_mutation_table_clear(&table);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(table.num_rows, 0);\n CU_ASSERT_EQUAL(table.derived_state_length, 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n tsk_mutation_table_free(&table);\n CU_ASSERT_EQUAL(ret, 0);\n tsk_mutation_table_free(&table2);\n CU_ASSERT_EQUAL(ret, 0);\n free(site);\n free(node);\n free(parent);\n free(time);\n free(derived_state);\n free(derived_state_offset);\n free(metadata);\n free(metadata_offset);\n}\n\nstatic void\ntest_mutation_table_takeset(void)\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_mutation_table_t source_table, table;\n tsk_size_t num_rows = 100;\n tsk_id_t j;\n tsk_id_t *site;\n tsk_id_t *node;\n tsk_id_t *parent;\n double *time;\n char *derived_state;\n tsk_size_t *derived_state_offset;\n char *metadata;\n tsk_size_t *metadata_offset;\n const char *test_derived_state = \"red\";\n tsk_size_t test_derived_state_length = 3;\n const char *test_metadata = \"test\";\n tsk_size_t test_metadata_length = 4;\n tsk_size_t zeros[num_rows + 1];\n tsk_id_t neg_ones[num_rows];\n double unknown_times[num_rows];\n\n tsk_memset(zeros, 0, (num_rows + 1) * sizeof(tsk_size_t));\n tsk_memset(neg_ones, 0xff, num_rows * sizeof(tsk_id_t));\n /* Make a table to copy from */\n ret = tsk_mutation_table_init(&source_table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n unknown_times[j] = TSK_UNKNOWN_TIME;\n ret_id = tsk_mutation_table_add_row(&source_table, j, j + 1, j + 2,\n (double) j + 3, test_derived_state, test_derived_state_length, test_metadata,\n test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n }\n\n /* Prepare arrays to be taken */\n site = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(site != NULL);\n tsk_memcpy(site, source_table.site, num_rows * sizeof(tsk_id_t));\n node = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(node != NULL);\n tsk_memcpy(node, source_table.node, num_rows * sizeof(tsk_id_t));\n parent = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(parent != NULL);\n tsk_memcpy(parent, source_table.parent, num_rows * sizeof(tsk_id_t));\n time = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(time != NULL);\n tsk_memcpy(time, source_table.time, num_rows * sizeof(double));\n derived_state = tsk_malloc(num_rows * test_derived_state_length * sizeof(char));\n CU_ASSERT_FATAL(derived_state != NULL);\n tsk_memcpy(derived_state, source_table.derived_state,\n num_rows * test_derived_state_length * sizeof(char));\n derived_state_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(derived_state_offset != NULL);\n tsk_memcpy(derived_state_offset, source_table.derived_state_offset,\n (num_rows + 1) * sizeof(tsk_size_t));\n metadata = tsk_malloc(num_rows * test_metadata_length * sizeof(char));\n CU_ASSERT_FATAL(metadata != NULL);\n tsk_memcpy(\n metadata, source_table.metadata, num_rows * test_metadata_length * sizeof(char));\n metadata_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(metadata_offset != NULL);\n tsk_memcpy(metadata_offset, source_table.metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t));\n\n ret = tsk_mutation_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Add one row so that we can check takeset frees it */\n ret_id = tsk_mutation_table_add_row(&table, 1, 1, 1, 1, test_derived_state,\n test_derived_state_length, test_metadata, test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n ret = tsk_mutation_table_takeset_columns(&table, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&source_table, &table, 0));\n\n /* Test error states, all of these must not take the array, or free existing */\n /* metadata and metadata offset must be simultaneously NULL or not */\n ret = tsk_mutation_table_takeset_columns(&table, num_rows, NULL, node, parent, time,\n derived_state, derived_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_mutation_table_takeset_columns(&table, num_rows, site, NULL, parent, time,\n derived_state, derived_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n // Parent and time not tested as they have deafults\n ret = tsk_mutation_table_takeset_columns(&table, num_rows, site, node, parent, time,\n NULL, derived_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_mutation_table_takeset_columns(&table, num_rows, site, node, parent, time,\n derived_state, NULL, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_mutation_table_takeset_columns(&table, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, NULL, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_mutation_table_takeset_columns(&table, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, metadata, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* Check error on bad derived_state offset */\n derived_state_offset[0] = 1;\n ret = tsk_mutation_table_takeset_columns(&table, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n\n /* Truncation after takeset keeps memory and max_rows */\n ret = tsk_mutation_table_clear(&table);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(table.max_rows, num_rows);\n\n // Re init non-optional arrays\n site = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(site != NULL);\n tsk_memcpy(site, source_table.site, num_rows * sizeof(tsk_id_t));\n node = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(node != NULL);\n tsk_memcpy(node, source_table.node, num_rows * sizeof(tsk_id_t));\n derived_state = tsk_malloc(num_rows * test_derived_state_length * sizeof(char));\n CU_ASSERT_FATAL(derived_state != NULL);\n tsk_memcpy(derived_state, source_table.derived_state,\n num_rows * test_derived_state_length * sizeof(char));\n derived_state_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(derived_state_offset != NULL);\n tsk_memcpy(derived_state_offset, source_table.derived_state_offset,\n (num_rows + 1) * sizeof(tsk_size_t));\n /* if metadata and offset are both null, all entries are zero length, if parent or\n * time are NULL they default to null values*/\n num_rows = 10;\n ret = tsk_mutation_table_takeset_columns(&table, num_rows, site, node, NULL, NULL,\n derived_state, derived_state_offset, NULL, NULL);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parent, neg_ones, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.time, unknown_times, num_rows * sizeof(tsk_id_t)), 0);\n\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata_offset, zeros, (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n ret = tsk_mutation_table_free(&table);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_mutation_table_free(&source_table);\n CU_ASSERT_EQUAL(ret, 0);\n}\n\nstatic void\ntest_mutation_table_update_row(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_mutation_table_t table;\n tsk_mutation_t row;\n const char *derived_state = \"XYZ\";\n const char *metadata = \"ABC\";\n\n ret = tsk_mutation_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id\n = tsk_mutation_table_add_row(&table, 0, 1, 2, 3, derived_state, 1, metadata, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_mutation_table_add_row(&table, 1, 2, 3, 4, derived_state, 2, metadata, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_mutation_table_add_row(&table, 2, 3, 4, 5, derived_state, 3, metadata, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_mutation_table_update_row(\n &table, 0, 1, 2, 3, 4, &derived_state[1], 1, &metadata[1], 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_mutation_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.site, 1);\n CU_ASSERT_EQUAL_FATAL(row.node, 2);\n CU_ASSERT_EQUAL_FATAL(row.parent, 3);\n CU_ASSERT_EQUAL_FATAL(row.time, 4);\n CU_ASSERT_EQUAL_FATAL(row.derived_state_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.derived_state[0], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_mutation_table_update_row(&table, 0, row.site + 1, row.node + 1,\n row.parent + 1, row.time + 1, row.derived_state, row.derived_state_length,\n row.metadata, row.metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_mutation_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.site, 2);\n CU_ASSERT_EQUAL_FATAL(row.node, 3);\n CU_ASSERT_EQUAL_FATAL(row.parent, 4);\n CU_ASSERT_EQUAL_FATAL(row.time, 5);\n CU_ASSERT_EQUAL_FATAL(row.derived_state_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.derived_state[0], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_mutation_table_update_row(&table, 0, row.site, row.node, row.parent,\n row.time, row.derived_state, row.derived_state_length, row.metadata,\n row.metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_mutation_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.site, 2);\n CU_ASSERT_EQUAL_FATAL(row.node, 3);\n CU_ASSERT_EQUAL_FATAL(row.parent, 4);\n CU_ASSERT_EQUAL_FATAL(row.time, 5);\n CU_ASSERT_EQUAL_FATAL(row.derived_state_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.derived_state[0], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_mutation_table_update_row(&table, 0, row.site, row.node, row.parent,\n row.time, NULL, 0, row.metadata, row.metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_mutation_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.site, 2);\n CU_ASSERT_EQUAL_FATAL(row.node, 3);\n CU_ASSERT_EQUAL_FATAL(row.parent, 4);\n CU_ASSERT_EQUAL_FATAL(row.time, 5);\n CU_ASSERT_EQUAL_FATAL(row.derived_state_length, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_mutation_table_update_row(\n &table, 0, 2, 3, 4, 5, derived_state, 3, metadata, 3);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_mutation_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.site, 2);\n CU_ASSERT_EQUAL_FATAL(row.node, 3);\n CU_ASSERT_EQUAL_FATAL(row.parent, 4);\n CU_ASSERT_EQUAL_FATAL(row.time, 5);\n CU_ASSERT_EQUAL_FATAL(row.derived_state_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.derived_state[0], 'X');\n CU_ASSERT_EQUAL_FATAL(row.derived_state[1], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.derived_state[2], 'Z');\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.metadata[2], 'C');\n\n ret = tsk_mutation_table_update_row(&table, 1, 5, 6, 7, 8, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_mutation_table_get_row(&table, 1, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.site, 5);\n CU_ASSERT_EQUAL_FATAL(row.node, 6);\n CU_ASSERT_EQUAL_FATAL(row.parent, 7);\n CU_ASSERT_EQUAL_FATAL(row.time, 8);\n CU_ASSERT_EQUAL_FATAL(row.derived_state_length, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 0);\n\n ret = tsk_mutation_table_get_row(&table, 2, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.site, 2);\n CU_ASSERT_EQUAL_FATAL(row.node, 3);\n CU_ASSERT_EQUAL_FATAL(row.parent, 4);\n CU_ASSERT_EQUAL_FATAL(row.time, 5);\n CU_ASSERT_EQUAL_FATAL(row.derived_state_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.derived_state[0], 'X');\n CU_ASSERT_EQUAL_FATAL(row.derived_state[1], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.derived_state[2], 'Z');\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.metadata[2], 'C');\n\n ret = tsk_mutation_table_update_row(&table, 3, 0, 0, 0, 0, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n\n tsk_mutation_table_free(&table);\n}\n\nstatic void\ntest_mutation_table_keep_rows(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_mutation_table_t source, t1, t2;\n tsk_mutation_t row;\n const char *derived_state = \"XYZ\";\n const char *metadata = \"ABC\";\n tsk_bool_t keep[3] = { 1, 1, 1 };\n tsk_id_t id_map[3];\n tsk_id_t indexes[] = { 0, 1, 2 };\n\n ret = tsk_mutation_table_init(&source, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_mutation_table_add_row(\n &source, 0, 1, -1, 3.0, derived_state, 1, metadata, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &source, 1, 2, -1, 4.0, derived_state, 2, metadata, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &source, 2, 3, 0, 5.0, derived_state, 3, metadata, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_mutation_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_mutation_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&t1, &source, 0));\n\n ret = tsk_mutation_table_keep_rows(&t1, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&t1, &source, 0));\n CU_ASSERT_EQUAL_FATAL(id_map[0], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], 2);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n ret = tsk_mutation_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_mutation_table_copy(&source, &t1, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[0] = 0;\n keep[1] = 1;\n keep[2] = 0;\n ret = tsk_mutation_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 1);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_mutation_table_get_row(&t1, 0, &row);\n CU_ASSERT_EQUAL_FATAL(row.site, 1);\n CU_ASSERT_EQUAL_FATAL(row.node, 2);\n CU_ASSERT_EQUAL_FATAL(row.parent, -1);\n CU_ASSERT_EQUAL_FATAL(row.time, 4);\n CU_ASSERT_EQUAL_FATAL(row.derived_state_length, 2);\n CU_ASSERT_EQUAL_FATAL(row.derived_state[0], 'X');\n CU_ASSERT_EQUAL_FATAL(row.derived_state[1], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 2);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n\n tsk_mutation_table_free(&t1);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n /* Keeping first n rows equivalent to truncate */\n for (j = 0; j < source.num_rows; j++) {\n ret = tsk_mutation_table_copy(&source, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_mutation_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_mutation_table_truncate(&t1, j + 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[j] = 1;\n ret = tsk_mutation_table_keep_rows(&t2, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&t1, &t2, 0));\n\n /* Adding the remaining rows back on to the table gives the original\n * table */\n ret = tsk_mutation_table_extend(\n &t2, &source, source.num_rows - j - 1, indexes + j + 1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&source, &t2, 0));\n\n tsk_mutation_table_free(&t1);\n tsk_mutation_table_free(&t2);\n }\n\n tsk_mutation_table_free(&source);\n}\n\nstatic void\ntest_mutation_table_keep_rows_parent_references(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_mutation_table_t source, t;\n tsk_bool_t keep[4] = { 1, 1, 1, 1 };\n tsk_id_t id_map[4];\n\n ret = tsk_mutation_table_init(&source, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_mutation_table_add_row(&source, 0, 1, -1, 3.0, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(&source, 1, 2, -1, 4.0, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(&source, 2, 3, 1, 5.0, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(&source, 3, 4, 1, 6.0, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_mutation_table_copy(&source, &t, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* OOB errors */\n t.parent[0] = -2;\n ret = tsk_mutation_table_keep_rows(&t, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(t.num_rows, 4);\n\n t.parent[0] = 4;\n ret = tsk_mutation_table_keep_rows(&t, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(t.num_rows, 4);\n /* But ignored if row is not kept */\n keep[0] = false;\n ret = tsk_mutation_table_keep_rows(&t, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_mutation_table_free(&t);\n\n ret = tsk_mutation_table_copy(&source, &t, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Try to remove referenced row 1 */\n keep[0] = true;\n keep[1] = false;\n ret = tsk_mutation_table_keep_rows(&t, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_KEEP_ROWS_MAP_TO_DELETED);\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&source, &t, 0));\n tsk_mutation_table_free(&t);\n\n ret = tsk_mutation_table_copy(&source, &t, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* remove unreferenced row 0 */\n keep[0] = false;\n keep[1] = true;\n ret = tsk_mutation_table_keep_rows(&t, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t.num_rows, 3);\n CU_ASSERT_EQUAL_FATAL(t.parent[0], TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(t.parent[1], 0);\n CU_ASSERT_EQUAL_FATAL(t.parent[2], 0);\n tsk_mutation_table_free(&t);\n\n /* Check that we don't change the table in error cases. */\n source.parent[3] = -2;\n ret = tsk_mutation_table_copy(&source, &t, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[0] = true;\n ret = tsk_mutation_table_keep_rows(&t, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&source, &t, 0));\n tsk_mutation_table_free(&t);\n\n /* Check that we don't change the table in error cases. */\n source.parent[3] = 0;\n ret = tsk_mutation_table_copy(&source, &t, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[0] = false;\n ret = tsk_mutation_table_keep_rows(&t, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_KEEP_ROWS_MAP_TO_DELETED);\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&source, &t, 0));\n tsk_mutation_table_free(&t);\n\n tsk_mutation_table_free(&source);\n}\n\nstatic void\ntest_migration_table(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_migration_table_t table, table2;\n tsk_size_t num_rows = 100;\n tsk_id_t j;\n tsk_id_t *node;\n tsk_id_t *source, *dest;\n double *left, *right, *time;\n tsk_migration_t migration, migration2;\n char *metadata;\n tsk_size_t *metadata_offset;\n const char *test_metadata = \"test\";\n tsk_size_t test_metadata_length = 4;\n char metadata_copy[test_metadata_length + 1];\n tsk_id_t row_subset[6] = { 1, 9, 1, 0, 2, 2 };\n tsk_size_t num_row_subset = 6;\n\n metadata_copy[test_metadata_length] = '\\0';\n ret = tsk_migration_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_migration_table_set_max_rows_increment(&table, 1);\n tsk_migration_table_print_state(&table, _devnull);\n ret = tsk_migration_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n ret_id = tsk_migration_table_add_row(&table, (double) j, (double) j, j, j, j,\n (double) j, test_metadata, test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n CU_ASSERT_EQUAL(table.left[j], j);\n CU_ASSERT_EQUAL(table.right[j], j);\n CU_ASSERT_EQUAL(table.node[j], j);\n CU_ASSERT_EQUAL(table.source[j], j);\n CU_ASSERT_EQUAL(table.dest[j], j);\n CU_ASSERT_EQUAL(table.time[j], j);\n CU_ASSERT_EQUAL(table.num_rows, (tsk_size_t) j + 1);\n CU_ASSERT_EQUAL(\n table.metadata_length, (tsk_size_t) (j + 1) * test_metadata_length);\n CU_ASSERT_EQUAL(table.metadata_offset[j + 1], table.metadata_length);\n /* check the metadata */\n tsk_memcpy(metadata_copy, table.metadata + table.metadata_offset[j],\n test_metadata_length);\n CU_ASSERT_NSTRING_EQUAL(metadata_copy, test_metadata, test_metadata_length);\n\n ret = tsk_migration_table_get_row(&table, (tsk_id_t) j, &migration);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(migration.id, j);\n CU_ASSERT_EQUAL(migration.left, j);\n CU_ASSERT_EQUAL(migration.right, j);\n CU_ASSERT_EQUAL(migration.node, j);\n CU_ASSERT_EQUAL(migration.source, j);\n CU_ASSERT_EQUAL(migration.dest, j);\n CU_ASSERT_EQUAL(migration.time, j);\n CU_ASSERT_EQUAL(migration.metadata_length, test_metadata_length);\n CU_ASSERT_NSTRING_EQUAL(migration.metadata, test_metadata, test_metadata_length);\n }\n ret = tsk_migration_table_get_row(&table, (tsk_id_t) num_rows, &migration);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATION_OUT_OF_BOUNDS);\n tsk_migration_table_print_state(&table, _devnull);\n ret = tsk_migration_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n num_rows *= 2;\n left = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(left != NULL);\n tsk_memset(left, 1, num_rows * sizeof(double));\n right = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(right != NULL);\n tsk_memset(right, 2, num_rows * sizeof(double));\n time = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(time != NULL);\n tsk_memset(time, 3, num_rows * sizeof(double));\n node = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(node != NULL);\n tsk_memset(node, 4, num_rows * sizeof(tsk_id_t));\n source = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(source != NULL);\n tsk_memset(source, 5, num_rows * sizeof(tsk_id_t));\n dest = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(dest != NULL);\n tsk_memset(dest, 6, num_rows * sizeof(tsk_id_t));\n metadata = tsk_malloc(num_rows * sizeof(char));\n tsk_memset(metadata, 'a', num_rows * sizeof(char));\n CU_ASSERT_FATAL(metadata != NULL);\n metadata_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(metadata_offset != NULL);\n for (j = 0; j < (tsk_id_t) num_rows + 1; j++) {\n metadata_offset[j] = (tsk_size_t) j;\n }\n\n ret = tsk_migration_table_set_columns(&table, num_rows, left, right, node, source,\n dest, time, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.left, left, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.right, right, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.node, node, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.source, source, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.dest, dest, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, num_rows);\n\n /* Append another num_rows */\n ret = tsk_migration_table_append_columns(&table, num_rows, left, right, node, source,\n dest, time, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.left, left, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.left + num_rows, left, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.right, right, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.right + num_rows, right, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.time + num_rows, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.node, node, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.node + num_rows, node, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.source, source, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.source + num_rows, source, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.dest, dest, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.dest + num_rows, dest, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata + num_rows, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.num_rows, 2 * num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, 2 * num_rows);\n\n /* Truncate back to num_rows */\n ret = tsk_migration_table_truncate(&table, num_rows);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.left, left, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.right, right, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.node, node, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.source, source, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.dest, dest, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, num_rows);\n\n /* Test equality with and without metadata */\n tsk_migration_table_copy(&table, &table2, 0);\n CU_ASSERT_TRUE(tsk_migration_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_migration_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Change the metadata values */\n table2.metadata[0] = 0;\n CU_ASSERT_FALSE(tsk_migration_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_migration_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Change the last metadata entry */\n table2.metadata_offset[table2.num_rows]\n = table2.metadata_offset[table2.num_rows - 1];\n CU_ASSERT_FALSE(tsk_migration_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_migration_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Delete all metadata */\n tsk_memset(table2.metadata_offset, 0,\n (table2.num_rows + 1) * sizeof(*table2.metadata_offset));\n CU_ASSERT_FALSE(tsk_migration_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_migration_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n tsk_migration_table_free(&table2);\n\n ret = tsk_migration_table_truncate(&table, num_rows + 1);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_TABLE_POSITION);\n\n /* inputs cannot be NULL */\n ret = tsk_migration_table_set_columns(&table, num_rows, NULL, right, node, source,\n dest, time, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_migration_table_set_columns(&table, num_rows, left, NULL, node, source,\n dest, time, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_migration_table_set_columns(&table, num_rows, left, right, NULL, source,\n dest, time, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_migration_table_set_columns(&table, num_rows, left, right, node, NULL,\n dest, time, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_migration_table_set_columns(&table, num_rows, left, right, node, source,\n NULL, time, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_migration_table_set_columns(&table, num_rows, left, right, node, source,\n dest, NULL, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_migration_table_set_columns(\n &table, num_rows, left, right, node, source, dest, time, NULL, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_migration_table_set_columns(\n &table, num_rows, left, right, node, source, dest, time, metadata, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n tsk_migration_table_clear(&table);\n CU_ASSERT_EQUAL(table.num_rows, 0);\n\n /* if metadata and metadata_offset are both null, all metadatas are zero length */\n num_rows = 10;\n tsk_memset(metadata_offset, 0, (num_rows + 1) * sizeof(tsk_size_t));\n ret = tsk_migration_table_set_columns(\n &table, num_rows, left, right, node, source, dest, time, NULL, NULL);\n CU_ASSERT_EQUAL(tsk_memcmp(table.left, left, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.right, right, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.node, node, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.source, source, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.dest, dest, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n ret = tsk_migration_table_append_columns(\n &table, num_rows, left, right, node, source, dest, time, NULL, NULL);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.left, left, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.left + num_rows, left, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.right, right, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.right + num_rows, right, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.time, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.time + num_rows, time, num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.node, node, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.node + num_rows, node, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.source, source, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.source + num_rows, source, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.dest, dest, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.dest + num_rows, dest, num_rows * sizeof(tsk_id_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset + num_rows, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, 2 * num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n tsk_migration_table_print_state(&table, _devnull);\n ret = tsk_migration_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Test extend method */\n ret = tsk_migration_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_migration_table_init(&table2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Can't extend from self */\n ret = tsk_migration_table_extend(&table, &table, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n\n /* Two empty tables */\n CU_ASSERT_TRUE(tsk_migration_table_equals(&table, &table2, 0));\n ret = tsk_migration_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_migration_table_equals(&table, &table2, 0));\n\n /* Row out of bounds */\n ret = tsk_migration_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATION_OUT_OF_BOUNDS);\n\n /* Num rows out of bounds */\n ret = tsk_migration_table_extend(&table, &table2, num_rows * 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATION_OUT_OF_BOUNDS);\n\n /* Copy rows in order if index NULL */\n ret = tsk_migration_table_set_columns(&table2, num_rows, left, right, node, source,\n dest, time, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_migration_table_equals(&table, &table2, 0));\n ret = tsk_migration_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_migration_table_equals(&table, &table2, 0));\n\n /* Copy nothing if index not NULL but length zero */\n ret = tsk_migration_table_extend(&table, &table2, 0, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_migration_table_equals(&table, &table2, 0));\n\n /* Copy first N rows in order if index NULL */\n ret = tsk_migration_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_migration_table_extend(&table, &table2, num_rows / 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_migration_table_truncate(&table2, num_rows / 2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_migration_table_equals(&table, &table2, 0));\n ret = tsk_migration_table_set_columns(&table2, num_rows, left, right, node, source,\n dest, time, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Copy a subset */\n ret = tsk_migration_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_migration_table_equals(&table, &table2, 0));\n ret = tsk_migration_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < (tsk_id_t) num_row_subset; j++) {\n ret = tsk_migration_table_get_row(&table, j, &migration);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_migration_table_get_row(&table2, row_subset[j], &migration2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(migration.source, migration2.source);\n CU_ASSERT_EQUAL(migration.dest, migration2.dest);\n CU_ASSERT_EQUAL(migration.node, migration2.node);\n CU_ASSERT_EQUAL(migration.left, migration2.left);\n CU_ASSERT_EQUAL(migration.right, migration2.right);\n CU_ASSERT_EQUAL(migration.time, migration2.time);\n CU_ASSERT_EQUAL(migration.metadata_length, migration2.metadata_length);\n CU_ASSERT_EQUAL(tsk_memcmp(migration.metadata, migration2.metadata,\n migration.metadata_length * sizeof(*migration.metadata)),\n 0);\n }\n\n ret = tsk_migration_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(table.metadata_schema_length, 0);\n CU_ASSERT_EQUAL(table.metadata_schema, NULL);\n const char *example = \"An example of metadata schema with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_length = (tsk_size_t) strlen(example);\n const char *example2 = \"A different example 🎄🌳🌴🌲🎋\";\n tsk_size_t example2_length = (tsk_size_t) strlen(example);\n tsk_migration_table_set_metadata_schema(&table, example, example_length);\n CU_ASSERT_EQUAL(table.metadata_schema_length, example_length);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_schema, example, example_length), 0);\n\n tsk_migration_table_copy(&table, &table2, TSK_NO_INIT);\n CU_ASSERT_EQUAL(table.metadata_schema_length, table2.metadata_schema_length);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata_schema, table2.metadata_schema, example_length), 0);\n tsk_migration_table_set_metadata_schema(&table2, example, example_length);\n CU_ASSERT_TRUE(tsk_migration_table_equals(&table, &table2, 0));\n tsk_migration_table_set_metadata_schema(&table2, example2, example2_length);\n CU_ASSERT_FALSE(tsk_migration_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(tsk_migration_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n\n tsk_migration_table_clear(&table);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(table.num_rows, 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n tsk_migration_table_free(&table);\n CU_ASSERT_EQUAL(ret, 0);\n tsk_migration_table_free(&table2);\n CU_ASSERT_EQUAL(ret, 0);\n\n free(left);\n free(right);\n free(time);\n free(node);\n free(source);\n free(dest);\n free(metadata);\n free(metadata_offset);\n}\n\nstatic void\ntest_migration_table_takeset(void)\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_migration_table_t source_table, table;\n tsk_size_t num_rows = 100;\n tsk_id_t j;\n double *left;\n double *right;\n tsk_id_t *node;\n tsk_id_t *source;\n tsk_id_t *dest;\n double *time;\n char *metadata;\n tsk_size_t *metadata_offset;\n const char *test_metadata = \"test\";\n tsk_size_t test_metadata_length = 4;\n tsk_size_t zeros[num_rows + 1];\n\n tsk_memset(zeros, 0, (num_rows + 1) * sizeof(tsk_size_t));\n /* Make a table to copy from */\n ret = tsk_migration_table_init(&source_table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n ret_id = tsk_migration_table_add_row(&source_table, (double) j, (double) j + 1,\n j + 2, j + 3, j + 4, (double) j + 5, test_metadata, test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n }\n\n /* Prepare arrays to be taken */\n left = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(left != NULL);\n tsk_memcpy(left, source_table.left, num_rows * sizeof(double));\n right = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(right != NULL);\n tsk_memcpy(right, source_table.right, num_rows * sizeof(double));\n node = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(node != NULL);\n tsk_memcpy(node, source_table.node, num_rows * sizeof(tsk_id_t));\n source = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(source != NULL);\n tsk_memcpy(source, source_table.source, num_rows * sizeof(tsk_id_t));\n dest = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(dest != NULL);\n tsk_memcpy(dest, source_table.dest, num_rows * sizeof(tsk_id_t));\n time = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(time != NULL);\n tsk_memcpy(time, source_table.time, num_rows * sizeof(double));\n metadata = tsk_malloc(num_rows * test_metadata_length * sizeof(char));\n CU_ASSERT_FATAL(metadata != NULL);\n tsk_memcpy(\n metadata, source_table.metadata, num_rows * test_metadata_length * sizeof(char));\n metadata_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(metadata_offset != NULL);\n tsk_memcpy(metadata_offset, source_table.metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t));\n\n ret = tsk_migration_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Add one row so that we can check takeset frees it */\n ret_id = tsk_migration_table_add_row(\n &table, 1, 1, 1, 1, 1, 1, test_metadata, test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n ret = tsk_migration_table_takeset_columns(&table, num_rows, left, right, node,\n source, dest, time, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_migration_table_equals(&source_table, &table, 0));\n\n /* Test error states, all of these must not take the array, or free existing */\n /* metadata and metadata offset must be simultaneously NULL or not */\n ret = tsk_migration_table_takeset_columns(&table, num_rows, NULL, right, node,\n source, dest, time, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_migration_table_takeset_columns(&table, num_rows, left, NULL, node, source,\n dest, time, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_migration_table_takeset_columns(&table, num_rows, left, right, NULL,\n source, dest, time, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_migration_table_takeset_columns(&table, num_rows, left, right, node, NULL,\n dest, time, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_migration_table_takeset_columns(&table, num_rows, left, right, node,\n source, NULL, time, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_migration_table_takeset_columns(&table, num_rows, left, right, node,\n source, dest, NULL, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_migration_table_takeset_columns(\n &table, num_rows, left, right, node, source, dest, time, NULL, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_migration_table_takeset_columns(\n &table, num_rows, left, right, node, source, dest, time, metadata, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* Truncation after takeset keeps memory and max_rows */\n ret = tsk_migration_table_clear(&table);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(table.max_rows, num_rows);\n\n // Re init non-optional arrays\n left = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(left != NULL);\n tsk_memcpy(left, source_table.left, num_rows * sizeof(double));\n right = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(right != NULL);\n tsk_memcpy(right, source_table.right, num_rows * sizeof(double));\n node = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(node != NULL);\n tsk_memcpy(node, source_table.node, num_rows * sizeof(tsk_id_t));\n source = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(source != NULL);\n tsk_memcpy(source, source_table.source, num_rows * sizeof(tsk_id_t));\n dest = tsk_malloc(num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(dest != NULL);\n tsk_memcpy(dest, source_table.dest, num_rows * sizeof(tsk_id_t));\n time = tsk_malloc(num_rows * sizeof(double));\n CU_ASSERT_FATAL(time != NULL);\n tsk_memcpy(time, source_table.time, num_rows * sizeof(double));\n /* if metadata and offset are both null, all entries are zero length */\n num_rows = 10;\n ret = tsk_migration_table_takeset_columns(\n &table, num_rows, left, right, node, source, dest, time, NULL, NULL);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata_offset, zeros, (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n ret = tsk_migration_table_free(&table);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_migration_table_free(&source_table);\n CU_ASSERT_EQUAL(ret, 0);\n}\n\nstatic void\ntest_migration_table_update_row(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_migration_table_t table;\n tsk_migration_t row;\n const char *metadata = \"ABC\";\n\n ret = tsk_migration_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_migration_table_add_row(&table, 0, 1.0, 2, 3, 4, 5, metadata, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_migration_table_add_row(&table, 1, 2.0, 3, 4, 5, 6, metadata, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_migration_table_add_row(&table, 2, 3.0, 4, 5, 6, 7, metadata, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_migration_table_update_row(&table, 0, 1, 2.0, 3, 4, 5, 6, &metadata[1], 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_migration_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.left, 1);\n CU_ASSERT_EQUAL_FATAL(row.right, 2.0);\n CU_ASSERT_EQUAL_FATAL(row.node, 3);\n CU_ASSERT_EQUAL_FATAL(row.source, 4);\n CU_ASSERT_EQUAL_FATAL(row.dest, 5);\n CU_ASSERT_EQUAL_FATAL(row.time, 6);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_migration_table_update_row(&table, 0, row.left + 1, row.right + 1,\n row.node + 1, row.source + 1, row.dest + 1, row.time + 1, row.metadata,\n row.metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_migration_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.left, 2);\n CU_ASSERT_EQUAL_FATAL(row.right, 3.0);\n CU_ASSERT_EQUAL_FATAL(row.node, 4);\n CU_ASSERT_EQUAL_FATAL(row.source, 5);\n CU_ASSERT_EQUAL_FATAL(row.dest, 6);\n CU_ASSERT_EQUAL_FATAL(row.time, 7);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_migration_table_update_row(&table, 0, 0, 0, 0, 0, 0, 0, metadata, 3);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_migration_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.left, 0);\n CU_ASSERT_EQUAL_FATAL(row.right, 0);\n CU_ASSERT_EQUAL_FATAL(row.node, 0);\n CU_ASSERT_EQUAL_FATAL(row.source, 0);\n CU_ASSERT_EQUAL_FATAL(row.dest, 0);\n CU_ASSERT_EQUAL_FATAL(row.time, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.metadata[2], 'C');\n\n ret = tsk_migration_table_update_row(&table, 1, 0, 0, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_migration_table_get_row(&table, 1, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.left, 0);\n CU_ASSERT_EQUAL_FATAL(row.right, 0);\n CU_ASSERT_EQUAL_FATAL(row.node, 0);\n CU_ASSERT_EQUAL_FATAL(row.source, 0);\n CU_ASSERT_EQUAL_FATAL(row.dest, 0);\n CU_ASSERT_EQUAL_FATAL(row.time, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 0);\n\n ret = tsk_migration_table_get_row(&table, 2, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.left, 2);\n CU_ASSERT_EQUAL_FATAL(row.right, 3.0);\n CU_ASSERT_EQUAL_FATAL(row.node, 4);\n CU_ASSERT_EQUAL_FATAL(row.source, 5);\n CU_ASSERT_EQUAL_FATAL(row.dest, 6);\n CU_ASSERT_EQUAL_FATAL(row.time, 7);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.metadata[2], 'C');\n\n ret = tsk_migration_table_update_row(&table, 3, 0, 0, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATION_OUT_OF_BOUNDS);\n\n tsk_migration_table_free(&table);\n}\n\nstatic void\ntest_migration_table_keep_rows(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_migration_table_t source, t1, t2;\n tsk_migration_t row;\n const char *metadata = \"ABC\";\n tsk_bool_t keep[3] = { 1, 1, 1 };\n tsk_id_t id_map[3];\n tsk_id_t indexes[] = { 0, 1, 2 };\n\n ret = tsk_migration_table_init(&source, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_migration_table_add_row(&source, 0, 1.0, 2, 3, 4, 5, metadata, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_migration_table_add_row(&source, 1, 2.0, 3, 4, 5, 6, metadata, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_migration_table_add_row(&source, 2, 3.0, 4, 5, 6, 7, metadata, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_migration_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_migration_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_migration_table_equals(&t1, &source, 0));\n\n ret = tsk_migration_table_keep_rows(&t1, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_migration_table_equals(&t1, &source, 0));\n CU_ASSERT_EQUAL_FATAL(id_map[0], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], 2);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n ret = tsk_migration_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_migration_table_copy(&source, &t1, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[0] = 0;\n keep[1] = 1;\n keep[2] = 0;\n ret = tsk_migration_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 1);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_migration_table_get_row(&t1, 0, &row);\n CU_ASSERT_EQUAL_FATAL(row.left, 1);\n CU_ASSERT_EQUAL_FATAL(row.right, 2);\n CU_ASSERT_EQUAL_FATAL(row.node, 3);\n CU_ASSERT_EQUAL_FATAL(row.source, 4);\n CU_ASSERT_EQUAL_FATAL(row.dest, 5);\n CU_ASSERT_EQUAL_FATAL(row.time, 6);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 2);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n\n tsk_migration_table_free(&t1);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n /* Keeping first n rows equivalent to truncate */\n for (j = 0; j < source.num_rows; j++) {\n ret = tsk_migration_table_copy(&source, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_migration_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_migration_table_truncate(&t1, j + 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[j] = 1;\n ret = tsk_migration_table_keep_rows(&t2, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_migration_table_equals(&t1, &t2, 0));\n\n /* Adding the remaining rows back on to the table gives the original\n * table */\n ret = tsk_migration_table_extend(\n &t2, &source, source.num_rows - j - 1, indexes + j + 1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_migration_table_equals(&source, &t2, 0));\n\n tsk_migration_table_free(&t1);\n tsk_migration_table_free(&t2);\n }\n\n tsk_migration_table_free(&source);\n}\n\nstatic void\ntest_individual_table(void)\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_individual_table_t table, table2;\n tsk_size_t num_rows = 100;\n tsk_id_t j;\n tsk_size_t k;\n tsk_flags_t *flags;\n double *location;\n tsk_id_t *parents;\n char *metadata;\n tsk_size_t *metadata_offset;\n tsk_size_t *parents_offset;\n tsk_size_t *location_offset;\n tsk_individual_t individual;\n tsk_individual_t individual2;\n const char *test_metadata = \"test\";\n tsk_size_t test_metadata_length = 4;\n char metadata_copy[test_metadata_length + 1];\n tsk_size_t spatial_dimension = 2;\n tsk_size_t num_parents = 3;\n double test_location[spatial_dimension];\n tsk_id_t test_parents[num_parents];\n tsk_size_t zeros[num_rows + 1];\n tsk_id_t row_subset[6] = { 1, 9, 1, 0, 2, 2 };\n tsk_size_t num_row_subset = 6;\n\n tsk_memset(zeros, 0, (num_rows + 1) * sizeof(tsk_size_t));\n for (k = 0; k < spatial_dimension; k++) {\n test_location[k] = (double) k;\n }\n for (k = 0; k < num_parents; k++) {\n test_parents[k] = (tsk_id_t) k + 42;\n }\n metadata_copy[test_metadata_length] = '\\0';\n ret = tsk_individual_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_individual_table_set_max_rows_increment(&table, 1);\n tsk_individual_table_set_max_metadata_length_increment(&table, 1);\n tsk_individual_table_set_max_location_length_increment(&table, 1);\n tsk_individual_table_set_max_parents_length_increment(&table, 1);\n\n tsk_individual_table_print_state(&table, _devnull);\n\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n ret_id = tsk_individual_table_add_row(&table, (tsk_flags_t) j, test_location,\n spatial_dimension, test_parents, num_parents, test_metadata,\n test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n CU_ASSERT_EQUAL(table.flags[j], (tsk_flags_t) j);\n for (k = 0; k < spatial_dimension; k++) {\n test_location[k] = (double) k;\n CU_ASSERT_EQUAL(\n table.location[spatial_dimension * (size_t) j + k], test_location[k]);\n }\n CU_ASSERT_EQUAL(\n table.metadata_length, (tsk_size_t) (j + 1) * test_metadata_length);\n CU_ASSERT_EQUAL(table.metadata_offset[j + 1], table.metadata_length);\n /* check the metadata */\n tsk_memcpy(metadata_copy, table.metadata + table.metadata_offset[j],\n test_metadata_length);\n CU_ASSERT_NSTRING_EQUAL(metadata_copy, test_metadata, test_metadata_length);\n\n ret = tsk_individual_table_get_row(&table, (tsk_id_t) j, &individual);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(individual.id, j);\n CU_ASSERT_EQUAL(individual.flags, (tsk_flags_t) j);\n CU_ASSERT_EQUAL(individual.location_length, spatial_dimension);\n CU_ASSERT_NSTRING_EQUAL(\n individual.location, test_location, spatial_dimension * sizeof(double));\n CU_ASSERT_EQUAL(individual.metadata_length, test_metadata_length);\n CU_ASSERT_NSTRING_EQUAL(\n individual.metadata, test_metadata, test_metadata_length);\n }\n\n /* Test equality with and without metadata */\n tsk_individual_table_copy(&table, &table2, 0);\n CU_ASSERT_TRUE(tsk_individual_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(\n tsk_individual_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Change the metadata values */\n table2.metadata[0] = 0;\n CU_ASSERT_FALSE(tsk_individual_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(\n tsk_individual_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Change the last metadata entry */\n table2.metadata_offset[table2.num_rows]\n = table2.metadata_offset[table2.num_rows - 1];\n CU_ASSERT_FALSE(tsk_individual_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(\n tsk_individual_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Delete all metadata */\n tsk_memset(table2.metadata_offset, 0,\n (table2.num_rows + 1) * sizeof(*table2.metadata_offset));\n CU_ASSERT_FALSE(tsk_individual_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(\n tsk_individual_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n tsk_individual_table_free(&table2);\n\n ret = tsk_individual_table_get_row(&table, (tsk_id_t) num_rows, &individual);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n tsk_individual_table_print_state(&table, _devnull);\n tsk_individual_table_clear(&table);\n CU_ASSERT_EQUAL(table.num_rows, 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n num_rows *= 2;\n flags = tsk_malloc(num_rows * sizeof(tsk_flags_t));\n CU_ASSERT_FATAL(flags != NULL);\n for (k = 0; k < num_rows; k++) {\n flags[k] = (tsk_flags_t) (k + num_rows);\n }\n location = tsk_malloc(spatial_dimension * num_rows * sizeof(double));\n CU_ASSERT_FATAL(location != NULL);\n for (k = 0; k < spatial_dimension * num_rows; k++) {\n location[k] = (double) (k + (num_rows * 2));\n }\n location_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(location_offset != NULL);\n for (j = 0; j < (tsk_id_t) num_rows + 1; j++) {\n location_offset[j] = (tsk_size_t) j * spatial_dimension;\n }\n parents = tsk_malloc(num_parents * num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(parents != NULL);\n for (k = 0; k < num_parents * num_rows; k++) {\n parents[k] = (tsk_id_t) (k + (num_rows * 4));\n }\n parents_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(parents_offset != NULL);\n for (j = 0; j < (tsk_id_t) num_rows + 1; j++) {\n parents_offset[j] = (tsk_size_t) j * num_parents;\n }\n metadata = tsk_malloc(num_rows * sizeof(char));\n for (k = 0; k < num_rows; k++) {\n metadata[k] = (char) ((k % 58) + 65);\n }\n CU_ASSERT_FATAL(metadata != NULL);\n metadata_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(metadata_offset != NULL);\n for (j = 0; j < (tsk_id_t) num_rows + 1; j++) {\n metadata_offset[j] = (tsk_size_t) j;\n }\n ret = tsk_individual_table_set_columns(&table, num_rows, flags, location,\n location_offset, parents, parents_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.flags, flags, num_rows * sizeof(tsk_flags_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.location, location,\n spatial_dimension * num_rows * sizeof(double)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.location_offset, location_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.parents, parents, num_parents * num_rows * sizeof(tsk_id_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parents_offset, parents_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.location_length, spatial_dimension * num_rows);\n CU_ASSERT_EQUAL(table.parents_length, num_parents * num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, num_rows);\n tsk_individual_table_print_state(&table, _devnull);\n\n /* Append another num_rows onto the end */\n ret = tsk_individual_table_append_columns(&table, num_rows, flags, location,\n location_offset, parents, parents_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.flags, flags, num_rows * sizeof(tsk_flags_t)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.flags + num_rows, flags, num_rows * sizeof(tsk_flags_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata + num_rows, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.location, location,\n spatial_dimension * num_rows * sizeof(double)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.location + spatial_dimension * num_rows, location,\n spatial_dimension * num_rows * sizeof(double)),\n 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.parents, parents, num_parents * num_rows * sizeof(tsk_id_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parents + num_parents * num_rows, parents,\n num_parents * num_rows * sizeof(tsk_id_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, 2 * num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, 2 * num_rows);\n CU_ASSERT_EQUAL(table.parents_length, 2 * num_parents * num_rows);\n CU_ASSERT_EQUAL(table.location_length, 2 * spatial_dimension * num_rows);\n tsk_individual_table_print_state(&table, _devnull);\n ret = tsk_individual_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Truncate back to num_rows */\n ret = tsk_individual_table_truncate(&table, num_rows);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.flags, flags, num_rows * sizeof(tsk_flags_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.location, location,\n spatial_dimension * num_rows * sizeof(double)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.location_offset, location_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.parents, parents, num_parents * num_rows * sizeof(tsk_id_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parents_offset, parents_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset, metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.location_length, spatial_dimension * num_rows);\n CU_ASSERT_EQUAL(table.parents_length, num_parents * num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, num_rows);\n tsk_individual_table_print_state(&table, _devnull);\n\n ret = tsk_individual_table_truncate(&table, num_rows + 1);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_TABLE_POSITION);\n\n /* flags can't be NULL */\n ret = tsk_individual_table_set_columns(&table, num_rows, NULL, location,\n location_offset, parents, parents_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n /* location and location offset must be simultaneously NULL or not */\n ret = tsk_individual_table_set_columns(&table, num_rows, flags, location, NULL,\n parents, parents_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_individual_table_set_columns(&table, num_rows, flags, NULL,\n location_offset, NULL, NULL, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n /* parents and parents offset must be simultaneously NULL or not */\n ret = tsk_individual_table_set_columns(&table, num_rows, flags, location,\n location_offset, parents, NULL, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_individual_table_set_columns(&table, num_rows, flags, location,\n location_offset, NULL, parents_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n /* metadata and metadata offset must be simultaneously NULL or not */\n ret = tsk_individual_table_set_columns(&table, num_rows, flags, location,\n location_offset, parents, parents_offset, NULL, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_individual_table_set_columns(&table, num_rows, flags, location,\n location_offset, parents, parents_offset, metadata, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* if location and location_offset are both null, all locations are zero length */\n num_rows = 10;\n ret = tsk_individual_table_set_columns(\n &table, num_rows, flags, NULL, NULL, NULL, NULL, NULL, NULL);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.location_offset, zeros, (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.location_length, 0);\n ret = tsk_individual_table_append_columns(\n &table, num_rows, flags, NULL, NULL, NULL, NULL, NULL, NULL);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.location_offset, zeros, (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.location_offset + num_rows, zeros,\n num_rows * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, 2 * num_rows);\n CU_ASSERT_EQUAL(table.location_length, 0);\n tsk_individual_table_print_state(&table, _devnull);\n ret = tsk_individual_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* if parents and parents_offset are both null, all parents are zero length */\n num_rows = 10;\n ret = tsk_individual_table_set_columns(\n &table, num_rows, flags, NULL, NULL, NULL, NULL, NULL, NULL);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.parents_offset, zeros, (num_rows + 1) * sizeof(tsk_size_t)), 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.parents_length, 0);\n ret = tsk_individual_table_append_columns(\n &table, num_rows, flags, NULL, NULL, NULL, NULL, NULL, NULL);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.parents_offset, zeros, (num_rows + 1) * sizeof(tsk_size_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parents_offset + num_rows, zeros,\n num_rows * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, 2 * num_rows);\n CU_ASSERT_EQUAL(table.parents_length, 0);\n tsk_individual_table_print_state(&table, _devnull);\n ret = tsk_individual_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* if metadata and metadata_offset are both null, all metadatas are zero length */\n num_rows = 10;\n ret = tsk_individual_table_set_columns(&table, num_rows, flags, location,\n location_offset, parents, parents_offset, NULL, NULL);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.flags, flags, num_rows * sizeof(tsk_flags_t)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.location, location,\n spatial_dimension * num_rows * sizeof(double)),\n 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.parents, parents, num_parents * num_rows * sizeof(double)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata_offset, zeros, (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n ret = tsk_individual_table_append_columns(&table, num_rows, flags, location,\n location_offset, parents, parents_offset, NULL, NULL);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.location, location,\n spatial_dimension * num_rows * sizeof(double)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.location + spatial_dimension * num_rows, location,\n spatial_dimension * num_rows * sizeof(double)),\n 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.parents, parents, num_parents * num_rows * sizeof(tsk_id_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.parents + num_parents * num_rows, parents,\n num_parents * num_rows * sizeof(tsk_id_t)),\n 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata_offset, zeros, (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_offset + num_rows, zeros,\n num_rows * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, 2 * num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n tsk_individual_table_print_state(&table, _devnull);\n tsk_individual_table_dump_text(&table, _devnull);\n\n /* Test extend method */\n ret = tsk_individual_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_individual_table_init(&table2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Can't extend from self */\n ret = tsk_individual_table_extend(&table, &table, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n\n /* Two empty tables */\n CU_ASSERT_TRUE(tsk_individual_table_equals(&table, &table2, 0));\n ret = tsk_individual_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_individual_table_equals(&table, &table2, 0));\n\n /* Row out of bounds */\n ret = tsk_individual_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n\n /* Num rows out of bounds */\n ret = tsk_individual_table_extend(&table, &table2, num_rows * 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n\n /* Copy rows in order if index NULL */\n ret = tsk_individual_table_set_columns(&table2, num_rows, flags, location,\n location_offset, parents, parents_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_individual_table_equals(&table, &table2, 0));\n ret = tsk_individual_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_individual_table_equals(&table, &table2, 0));\n\n /* Copy nothing if index not NULL but length zero */\n ret = tsk_individual_table_extend(&table, &table2, 0, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_individual_table_equals(&table, &table2, 0));\n\n /* Copy first N rows in order if index NULL */\n ret = tsk_individual_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_individual_table_extend(&table, &table2, num_rows / 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_individual_table_truncate(&table2, num_rows / 2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_individual_table_equals(&table, &table2, 0));\n ret = tsk_individual_table_set_columns(&table2, num_rows, flags, location,\n location_offset, parents, parents_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Copy a subset */\n ret = tsk_individual_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_individual_table_equals(&table, &table2, 0));\n ret = tsk_individual_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (k = 0; k < num_row_subset; k++) {\n ret = tsk_individual_table_get_row(&table, (tsk_id_t) k, &individual);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_individual_table_get_row(&table2, row_subset[k], &individual2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(individual.flags, individual2.flags);\n CU_ASSERT_EQUAL(individual.location_length, individual2.location_length);\n CU_ASSERT_EQUAL(individual.parents_length, individual2.parents_length);\n CU_ASSERT_EQUAL(individual.metadata_length, individual2.metadata_length);\n CU_ASSERT_EQUAL(tsk_memcmp(individual.location, individual2.location,\n individual.location_length * sizeof(*individual.location)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(individual.parents, individual2.parents,\n individual.parents_length * sizeof(*individual.parents)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(individual.metadata, individual2.metadata,\n individual.metadata_length * sizeof(*individual.metadata)),\n 0);\n }\n\n ret = tsk_individual_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(table.metadata_schema_length, 0);\n CU_ASSERT_EQUAL(table.metadata_schema, NULL);\n const char *example = \"An example of metadata schema with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_length = (tsk_size_t) strlen(example);\n const char *example2 = \"A different example 🎄🌳🌴🌲🎋\";\n tsk_size_t example2_length = (tsk_size_t) strlen(example);\n tsk_individual_table_set_metadata_schema(&table, example, example_length);\n CU_ASSERT_EQUAL(table.metadata_schema_length, example_length);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_schema, example, example_length), 0);\n\n tsk_individual_table_copy(&table, &table2, TSK_NO_INIT);\n CU_ASSERT_EQUAL(table.metadata_schema_length, table2.metadata_schema_length);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata_schema, table2.metadata_schema, example_length), 0);\n tsk_individual_table_set_metadata_schema(&table2, example, example_length);\n CU_ASSERT_TRUE(tsk_individual_table_equals(&table, &table2, 0));\n tsk_individual_table_set_metadata_schema(&table2, example2, example2_length);\n CU_ASSERT_FALSE(tsk_individual_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(\n tsk_individual_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n\n tsk_individual_table_clear(&table);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(table.num_rows, 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n ret = tsk_individual_table_free(&table);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_individual_table_free(&table2);\n CU_ASSERT_EQUAL(ret, 0);\n free(flags);\n free(location);\n free(location_offset);\n free(parents);\n free(parents_offset);\n free(metadata);\n free(metadata_offset);\n}\n\nstatic void\ntest_individual_table_takeset(void)\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_individual_table_t source_table, table;\n tsk_size_t num_rows = 100;\n tsk_id_t j;\n tsk_size_t k;\n tsk_flags_t *flags;\n double *location;\n tsk_id_t *parents;\n char *metadata;\n tsk_size_t *metadata_offset;\n tsk_size_t *parents_offset;\n tsk_size_t *location_offset;\n tsk_size_t spatial_dimension = 2;\n tsk_size_t num_parents = 3;\n const char *test_metadata = \"test\";\n tsk_size_t test_metadata_length = 4;\n double test_location[spatial_dimension];\n tsk_id_t test_parents[num_parents];\n tsk_size_t zeros[num_rows + 1];\n\n tsk_memset(zeros, 0, (num_rows + 1) * sizeof(tsk_size_t));\n /* Make a table to copy from */\n ret = tsk_individual_table_init(&source_table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (k = 0; k < spatial_dimension; k++) {\n test_location[k] = (double) k;\n }\n for (k = 0; k < num_parents; k++) {\n test_parents[k] = (tsk_id_t) k + 42;\n }\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n ret_id = tsk_individual_table_add_row(&source_table, (tsk_flags_t) j,\n test_location, spatial_dimension, test_parents, num_parents, test_metadata,\n test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n }\n\n /* Prepare arrays to be taken */\n flags = tsk_malloc(num_rows * sizeof(tsk_flags_t));\n CU_ASSERT_FATAL(flags != NULL);\n tsk_memcpy(flags, source_table.flags, num_rows * sizeof(tsk_flags_t));\n location = tsk_malloc(spatial_dimension * num_rows * sizeof(double));\n CU_ASSERT_FATAL(location != NULL);\n tsk_memcpy(\n location, source_table.location, spatial_dimension * num_rows * sizeof(double));\n location_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(location_offset != NULL);\n tsk_memcpy(location_offset, source_table.location_offset,\n (num_rows + 1) * sizeof(tsk_size_t));\n parents = tsk_malloc(num_parents * num_rows * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(parents != NULL);\n tsk_memcpy(parents, source_table.parents, num_parents * num_rows * sizeof(tsk_id_t));\n parents_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(parents_offset != NULL);\n tsk_memcpy(parents_offset, source_table.parents_offset,\n (num_rows + 1) * sizeof(tsk_size_t));\n metadata = tsk_malloc(num_rows * test_metadata_length * sizeof(char));\n CU_ASSERT_FATAL(metadata != NULL);\n tsk_memcpy(\n metadata, source_table.metadata, num_rows * test_metadata_length * sizeof(char));\n metadata_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(metadata_offset != NULL);\n tsk_memcpy(metadata_offset, source_table.metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t));\n\n ret = tsk_individual_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Add one row so that we can check takeset frees it */\n ret_id = tsk_individual_table_add_row(&table, (tsk_flags_t) 1, test_location,\n spatial_dimension, test_parents, num_parents, test_metadata,\n test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n ret = tsk_individual_table_takeset_columns(&table, num_rows, flags, location,\n location_offset, parents, parents_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_individual_table_equals(&source_table, &table, 0));\n\n /* Test error states, all of these must not take the array, or free existing */\n /* location and location offset must be simultaneously NULL or not */\n ret = tsk_individual_table_takeset_columns(&table, num_rows, flags, location, NULL,\n parents, parents_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_individual_table_takeset_columns(&table, num_rows, flags, NULL,\n location_offset, NULL, NULL, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n /* parents and parents offset must be simultaneously NULL or not */\n ret = tsk_individual_table_takeset_columns(&table, num_rows, flags, location,\n location_offset, parents, NULL, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_individual_table_takeset_columns(&table, num_rows, flags, location,\n location_offset, NULL, parents_offset, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n /* metadata and metadata offset must be simultaneously NULL or not */\n ret = tsk_individual_table_takeset_columns(&table, num_rows, flags, location,\n location_offset, parents, parents_offset, NULL, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_individual_table_takeset_columns(&table, num_rows, flags, location,\n location_offset, parents, parents_offset, metadata, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* Truncation after takeset keeps memory and max_rows */\n ret = tsk_individual_table_clear(&table);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(table.max_rows, num_rows);\n\n /* if ragged array and offset are both null, all entries are zero length,\n NULL flags mean all zero entries */\n num_rows = 10;\n ret = tsk_individual_table_takeset_columns(\n &table, num_rows, NULL, NULL, NULL, NULL, NULL, NULL, NULL);\n CU_ASSERT_EQUAL(tsk_memcmp(table.flags, zeros, num_rows * sizeof(tsk_flags_t)), 0);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.location_offset, zeros, (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.location_length, 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.parents_offset, zeros, (num_rows + 1) * sizeof(tsk_size_t)), 0);\n CU_ASSERT_EQUAL(table.parents_length, 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata_offset, zeros, (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n ret = tsk_individual_table_free(&table);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_individual_table_free(&source_table);\n CU_ASSERT_EQUAL(ret, 0);\n}\n\nstatic void\ntest_individual_table_update_row(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_individual_table_t table;\n tsk_individual_t row;\n double location[] = { 0, 1, 2 };\n tsk_id_t parents[] = { 0, 1, 2 };\n const char *metadata = \"ABC\";\n\n ret = tsk_individual_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id\n = tsk_individual_table_add_row(&table, 0, location, 1, parents, 1, metadata, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_individual_table_add_row(&table, 1, location, 2, parents, 2, metadata, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_individual_table_add_row(&table, 2, location, 3, parents, 3, metadata, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_individual_table_update_row(\n &table, 0, 1, &location[1], 1, &parents[1], 1, &metadata[1], 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_individual_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.flags, 1);\n CU_ASSERT_EQUAL_FATAL(row.location_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.location[0], 1.0);\n CU_ASSERT_EQUAL_FATAL(row.parents_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.parents[0], 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_individual_table_update_row(&table, 0, row.flags + 1, row.location,\n row.location_length, row.parents, row.parents_length, row.metadata,\n row.metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_individual_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.flags, 2);\n CU_ASSERT_EQUAL_FATAL(row.location_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.location[0], 1.0);\n CU_ASSERT_EQUAL_FATAL(row.parents_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.parents[0], 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_individual_table_update_row(&table, 0, row.flags, location, 1, row.parents,\n row.parents_length, row.metadata, row.metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_individual_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.flags, 2);\n CU_ASSERT_EQUAL_FATAL(row.location_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.location[0], 0.0);\n CU_ASSERT_EQUAL_FATAL(row.parents_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.parents[0], 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_individual_table_update_row(&table, 0, row.flags, NULL, 0, row.parents,\n row.parents_length, row.metadata, row.metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_individual_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.flags, 2);\n CU_ASSERT_EQUAL_FATAL(row.location_length, 0);\n CU_ASSERT_EQUAL_FATAL(row.parents_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.parents[0], 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_individual_table_update_row(\n &table, 0, 2, location, 3, parents, 3, metadata, 3);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_individual_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.flags, 2);\n CU_ASSERT_EQUAL_FATAL(row.location_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.location[0], 0);\n CU_ASSERT_EQUAL_FATAL(row.location[1], 1);\n CU_ASSERT_EQUAL_FATAL(row.location[2], 2);\n CU_ASSERT_EQUAL_FATAL(row.parents_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.parents[0], 0);\n CU_ASSERT_EQUAL_FATAL(row.parents[1], 1);\n CU_ASSERT_EQUAL_FATAL(row.parents[2], 2);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.metadata[2], 'C');\n\n ret = tsk_individual_table_update_row(&table, 1, 5, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_individual_table_get_row(&table, 1, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.flags, 5);\n CU_ASSERT_EQUAL_FATAL(row.location_length, 0);\n CU_ASSERT_EQUAL_FATAL(row.parents_length, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 0);\n\n ret = tsk_individual_table_get_row(&table, 2, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.flags, 2);\n CU_ASSERT_EQUAL_FATAL(row.location_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.location[0], 0);\n CU_ASSERT_EQUAL_FATAL(row.location[1], 1);\n CU_ASSERT_EQUAL_FATAL(row.location[2], 2);\n CU_ASSERT_EQUAL_FATAL(row.parents_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.parents[0], 0);\n CU_ASSERT_EQUAL_FATAL(row.parents[1], 1);\n CU_ASSERT_EQUAL_FATAL(row.parents[2], 2);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.metadata[2], 'C');\n\n ret = tsk_individual_table_update_row(&table, 3, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n\n tsk_individual_table_free(&table);\n}\n\nstatic void\ntest_individual_table_keep_rows(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_individual_t row;\n double location[] = { 0, 1, 2 };\n tsk_id_t parents[] = { -1, 1, -1 };\n const char *metadata = \"ABC\";\n tsk_bool_t keep[3] = { 1, 1, 1 };\n tsk_id_t indexes[] = { 0, 1, 2 };\n tsk_id_t id_map[3];\n tsk_individual_table_t source, t1, t2;\n tsk_size_t j;\n\n ret = tsk_individual_table_init(&source, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id\n = tsk_individual_table_add_row(&source, 0, location, 1, parents, 1, metadata, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_individual_table_add_row(&source, 1, location, 2, parents, 2, metadata, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_individual_table_add_row(&source, 2, location, 3, parents, 3, metadata, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_individual_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_individual_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_individual_table_equals(&t1, &source, 0));\n\n ret = tsk_individual_table_keep_rows(&t1, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_individual_table_equals(&t1, &source, 0));\n CU_ASSERT_EQUAL_FATAL(id_map[0], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], 2);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n ret = tsk_individual_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_individual_table_copy(&source, &t1, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[0] = 0;\n keep[1] = 1;\n keep[2] = 0;\n ret = tsk_individual_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 1);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_individual_table_get_row(&t1, 0, &row);\n CU_ASSERT_EQUAL_FATAL(row.flags, 1);\n CU_ASSERT_EQUAL_FATAL(row.parents_length, 2);\n CU_ASSERT_EQUAL_FATAL(row.parents[0], -1);\n CU_ASSERT_EQUAL_FATAL(row.parents[1], 0);\n CU_ASSERT_EQUAL_FATAL(row.location_length, 2);\n CU_ASSERT_EQUAL_FATAL(row.location[0], 0);\n CU_ASSERT_EQUAL_FATAL(row.location[1], 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 2);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n\n tsk_individual_table_free(&t1);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n /* Keeping first n rows equivalent to truncate */\n for (j = 0; j < source.num_rows; j++) {\n ret = tsk_individual_table_copy(&source, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_individual_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_individual_table_truncate(&t1, j + 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[j] = 1;\n ret = tsk_individual_table_keep_rows(&t2, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_individual_table_equals(&t1, &t2, 0));\n\n /* Adding the remaining rows back on to the table gives the original\n * table */\n ret = tsk_individual_table_extend(\n &t2, &source, source.num_rows - j - 1, indexes + j + 1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_individual_table_equals(&source, &t2, 0));\n\n tsk_individual_table_free(&t1);\n tsk_individual_table_free(&t2);\n }\n\n tsk_individual_table_free(&source);\n}\n\nstatic void\ntest_individual_table_keep_rows_parent_references(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_individual_table_t source, t;\n tsk_bool_t keep[] = { 1, 1, 1, 1 };\n tsk_id_t parents[] = { -1, 1, 2 };\n tsk_id_t id_map[4];\n\n ret = tsk_individual_table_init(&source, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_individual_table_add_row(&source, 0, NULL, 0, parents, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(&source, 0, NULL, 0, parents, 3, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(&source, 0, NULL, 0, parents, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(&source, 0, NULL, 0, parents, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_individual_table_copy(&source, &t, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* OOB errors */\n t.parents[0] = -2;\n ret = tsk_individual_table_keep_rows(&t, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(t.num_rows, 4);\n\n t.parents[0] = 4;\n ret = tsk_individual_table_keep_rows(&t, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(t.num_rows, 4);\n /* But ignored if row is not kept */\n keep[0] = false;\n ret = tsk_individual_table_keep_rows(&t, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_individual_table_free(&t);\n\n ret = tsk_individual_table_copy(&source, &t, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Try to remove referenced row 2 */\n keep[0] = true;\n keep[2] = false;\n ret = tsk_individual_table_keep_rows(&t, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_KEEP_ROWS_MAP_TO_DELETED);\n CU_ASSERT_TRUE(tsk_individual_table_equals(&source, &t, 0));\n tsk_individual_table_free(&t);\n\n ret = tsk_individual_table_copy(&source, &t, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* remove unreferenced row 0 */\n keep[0] = false;\n keep[2] = true;\n ret = tsk_individual_table_keep_rows(&t, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t.num_rows, 3);\n CU_ASSERT_EQUAL_FATAL(t.parents[0], TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(t.parents[1], 0);\n CU_ASSERT_EQUAL_FATAL(t.parents[2], 1);\n tsk_individual_table_free(&t);\n\n /* Check that we don't change the table in error cases. */\n source.parents[1] = -2;\n ret = tsk_individual_table_copy(&source, &t, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[0] = true;\n ret = tsk_individual_table_keep_rows(&t, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n CU_ASSERT_TRUE(tsk_individual_table_equals(&source, &t, 0));\n tsk_individual_table_free(&t);\n\n /* Check that we don't change the table in error cases. */\n source.parents[1] = 0;\n ret = tsk_individual_table_copy(&source, &t, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[0] = false;\n ret = tsk_individual_table_keep_rows(&t, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_KEEP_ROWS_MAP_TO_DELETED);\n CU_ASSERT_TRUE(tsk_individual_table_equals(&source, &t, 0));\n tsk_individual_table_free(&t);\n\n tsk_individual_table_free(&source);\n}\n\nstatic void\ntest_population_table(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_population_table_t table, table2;\n tsk_size_t num_rows = 100;\n tsk_size_t max_len = 20;\n tsk_size_t k, len;\n tsk_id_t j;\n char *metadata;\n char c[max_len + 1];\n tsk_size_t *metadata_offset;\n tsk_population_t population, population2;\n tsk_id_t row_subset[6] = { 1, 9, 1, 0, 2, 2 };\n tsk_size_t num_row_subset = 6;\n\n for (j = 0; j < (tsk_id_t) max_len; j++) {\n c[j] = (char) ('A' + j);\n }\n\n ret = tsk_population_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_population_table_set_max_rows_increment(&table, 1);\n tsk_population_table_set_max_metadata_length_increment(&table, 1);\n tsk_population_table_print_state(&table, _devnull);\n ret = tsk_population_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Adding zero length metadata with NULL should be fine */\n\n ret_id = tsk_population_table_add_row(&table, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n CU_ASSERT_EQUAL(table.num_rows, 1);\n CU_ASSERT_EQUAL(table.metadata_offset[0], 0);\n CU_ASSERT_EQUAL(table.metadata_offset[1], 0);\n tsk_population_table_clear(&table);\n CU_ASSERT_EQUAL(table.num_rows, 0);\n\n len = 0;\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n k = TSK_MIN((tsk_size_t) j + 1, max_len);\n ret_id = tsk_population_table_add_row(&table, c, k);\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n CU_ASSERT_EQUAL(table.metadata_offset[j], len);\n CU_ASSERT_EQUAL(table.num_rows, (tsk_size_t) j + 1);\n len += k;\n CU_ASSERT_EQUAL(table.metadata_offset[j + 1], len);\n CU_ASSERT_EQUAL(table.metadata_length, len);\n\n ret = tsk_population_table_get_row(&table, (tsk_id_t) j, &population);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(population.id, j);\n CU_ASSERT_EQUAL(population.metadata_length, k);\n CU_ASSERT_NSTRING_EQUAL(population.metadata, c, k);\n }\n\n /* Test equality with and without metadata */\n tsk_population_table_copy(&table, &table2, 0);\n CU_ASSERT_TRUE(tsk_population_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(\n tsk_population_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Change the metadata values */\n table2.metadata[0] = 0;\n CU_ASSERT_FALSE(tsk_population_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(\n tsk_population_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Change the last metadata entry */\n table2.metadata_offset[table2.num_rows]\n = table2.metadata_offset[table2.num_rows - 1];\n CU_ASSERT_FALSE(tsk_population_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(\n tsk_population_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n /* Delete all metadata */\n tsk_memset(table2.metadata_offset, 0,\n (table2.num_rows + 1) * sizeof(*table2.metadata_offset));\n CU_ASSERT_FALSE(tsk_population_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(\n tsk_population_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n tsk_population_table_free(&table2);\n\n ret = tsk_population_table_get_row(&table, (tsk_id_t) num_rows, &population);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n tsk_population_table_print_state(&table, _devnull);\n ret = tsk_population_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n num_rows *= 2;\n metadata = tsk_malloc(num_rows * sizeof(char));\n CU_ASSERT_FATAL(metadata != NULL);\n metadata_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(metadata_offset != NULL);\n\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n metadata[j] = 'M';\n metadata_offset[j] = (tsk_size_t) j;\n }\n\n metadata_offset[num_rows] = num_rows;\n ret = tsk_population_table_set_columns(&table, num_rows, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, num_rows);\n\n /* Append another num_rows */\n ret = tsk_population_table_append_columns(\n &table, num_rows, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata + num_rows, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.metadata_length, 2 * num_rows);\n CU_ASSERT_EQUAL(table.num_rows, 2 * num_rows);\n\n /* Truncate back to num_rows */\n ret = tsk_population_table_truncate(&table, num_rows);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata, metadata, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.metadata_length, num_rows);\n\n ret = tsk_population_table_truncate(&table, num_rows + 1);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_TABLE_POSITION);\n\n /* Metadata = NULL gives an error */\n ret = tsk_population_table_set_columns(&table, num_rows, NULL, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_population_table_set_columns(&table, num_rows, metadata, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_population_table_set_columns(&table, num_rows, NULL, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* Test extend method */\n ret = tsk_population_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_population_table_init(&table2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Can't extend from self */\n ret = tsk_population_table_extend(&table, &table, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n\n /* Two empty tables */\n CU_ASSERT_TRUE(tsk_population_table_equals(&table, &table2, 0));\n ret = tsk_population_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_population_table_equals(&table, &table2, 0));\n\n /* Row out of bounds */\n ret = tsk_population_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n\n /* Num rows out of bounds */\n ret = tsk_population_table_extend(&table, &table2, num_rows * 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n\n /* Copy rows in order if index NULL */\n ret = tsk_population_table_set_columns(&table2, num_rows, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_population_table_equals(&table, &table2, 0));\n ret = tsk_population_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_population_table_equals(&table, &table2, 0));\n\n /* Copy nothing if index not NULL but length zero */\n ret = tsk_population_table_extend(&table, &table2, 0, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_population_table_equals(&table, &table2, 0));\n\n /* Copy first N rows in order if index NULL */\n ret = tsk_population_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_population_table_extend(&table, &table2, num_rows / 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_population_table_truncate(&table2, num_rows / 2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_population_table_equals(&table, &table2, 0));\n ret = tsk_population_table_set_columns(&table2, num_rows, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Copy a subset */\n ret = tsk_population_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_population_table_equals(&table, &table2, 0));\n ret = tsk_population_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (k = 0; k < num_row_subset; k++) {\n ret = tsk_population_table_get_row(&table, (tsk_id_t) k, &population);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_population_table_get_row(&table2, row_subset[k], &population2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(population.metadata_length, population2.metadata_length);\n CU_ASSERT_EQUAL(tsk_memcmp(population.metadata, population2.metadata,\n population.metadata_length * sizeof(*population.metadata)),\n 0);\n }\n\n /* Test for bad offsets */\n metadata_offset[0] = 1;\n ret = tsk_population_table_set_columns(&table, num_rows, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n metadata_offset[0] = 0;\n metadata_offset[num_rows] = 0;\n ret = tsk_population_table_set_columns(&table, num_rows, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n\n ret = tsk_population_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(table.metadata_schema_length, 0);\n CU_ASSERT_EQUAL(table.metadata_schema, NULL);\n const char *example = \"An example of metadata schema with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_length = (tsk_size_t) strlen(example);\n const char *example2 = \"A different example 🎄🌳🌴🌲🎋\";\n tsk_size_t example2_length = (tsk_size_t) strlen(example);\n tsk_population_table_set_metadata_schema(&table, example, example_length);\n CU_ASSERT_EQUAL(table.metadata_schema_length, example_length);\n CU_ASSERT_EQUAL(tsk_memcmp(table.metadata_schema, example, example_length), 0);\n\n tsk_population_table_copy(&table, &table2, TSK_NO_INIT);\n CU_ASSERT_EQUAL(table.metadata_schema_length, table2.metadata_schema_length);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.metadata_schema, table2.metadata_schema, example_length), 0);\n tsk_population_table_set_metadata_schema(&table2, example, example_length);\n CU_ASSERT_TRUE(tsk_population_table_equals(&table, &table2, 0));\n tsk_population_table_set_metadata_schema(&table2, example2, example2_length);\n CU_ASSERT_FALSE(tsk_population_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(\n tsk_population_table_equals(&table, &table2, TSK_CMP_IGNORE_METADATA));\n\n tsk_population_table_clear(&table);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(table.num_rows, 0);\n CU_ASSERT_EQUAL(table.metadata_length, 0);\n\n tsk_population_table_free(&table);\n CU_ASSERT_EQUAL(ret, 0);\n tsk_population_table_free(&table2);\n CU_ASSERT_EQUAL(ret, 0);\n\n free(metadata);\n free(metadata_offset);\n}\n\nstatic void\ntest_population_table_takeset(void)\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_population_table_t source_table, table;\n tsk_size_t num_rows = 100;\n tsk_id_t j;\n char *metadata;\n tsk_size_t *metadata_offset;\n const char *test_metadata = \"test\";\n tsk_size_t test_metadata_length = 4;\n tsk_size_t zeros[num_rows + 1];\n\n tsk_memset(zeros, 0, (num_rows + 1) * sizeof(tsk_size_t));\n /* Make a table to copy from */\n ret = tsk_population_table_init(&source_table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n ret_id = tsk_population_table_add_row(\n &source_table, test_metadata, test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n }\n\n /* Prepare arrays to be taken */\n metadata = tsk_malloc(num_rows * test_metadata_length * sizeof(char));\n CU_ASSERT_FATAL(metadata != NULL);\n tsk_memcpy(\n metadata, source_table.metadata, num_rows * test_metadata_length * sizeof(char));\n metadata_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(metadata_offset != NULL);\n tsk_memcpy(metadata_offset, source_table.metadata_offset,\n (num_rows + 1) * sizeof(tsk_size_t));\n\n ret = tsk_population_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Add one row so that we can check takeset frees it */\n ret_id = tsk_population_table_add_row(&table, test_metadata, test_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n ret = tsk_population_table_takeset_columns(\n &table, num_rows, metadata, metadata_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_population_table_equals(&source_table, &table, 0));\n\n /* Test error states, all of these must not take the array, or free existing */\n ret = tsk_population_table_takeset_columns(&table, num_rows, NULL, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_population_table_takeset_columns(&table, num_rows, metadata, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_population_table_takeset_columns(&table, num_rows, NULL, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* Test bad offset */\n metadata_offset[0] = 1;\n ret = tsk_population_table_takeset_columns(\n &table, num_rows, metadata, metadata_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n\n /* Truncation after takeset keeps memory and max_rows */\n ret = tsk_population_table_clear(&table);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(table.max_rows, num_rows);\n\n ret = tsk_population_table_free(&table);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_population_table_free(&source_table);\n CU_ASSERT_EQUAL(ret, 0);\n}\n\nstatic void\ntest_population_table_update_row(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_population_table_t table;\n tsk_population_t row;\n const char *metadata = \"ABC\";\n\n ret = tsk_population_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_population_table_add_row(&table, metadata, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_population_table_add_row(&table, metadata, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_population_table_add_row(&table, metadata, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_population_table_update_row(&table, 0, &metadata[1], 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_population_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_population_table_update_row(&table, 0, row.metadata, row.metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_population_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'B');\n\n ret = tsk_population_table_update_row(&table, 0, metadata, 3);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_population_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.metadata[2], 'C');\n\n ret = tsk_population_table_update_row(&table, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_population_table_get_row(&table, 1, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 0);\n\n ret = tsk_population_table_get_row(&table, 2, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.metadata[2], 'C');\n\n ret = tsk_population_table_update_row(&table, 3, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n\n tsk_population_table_free(&table);\n}\n\nstatic void\ntest_population_table_keep_rows(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_population_table_t source, t1, t2;\n tsk_population_t row;\n const char *metadata = \"ABC\";\n tsk_bool_t keep[3] = { 1, 1, 1 };\n tsk_id_t id_map[3];\n tsk_id_t indexes[] = { 0, 1, 2 };\n\n ret = tsk_population_table_init(&source, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_population_table_add_row(&source, metadata, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_population_table_add_row(&source, metadata, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_population_table_add_row(&source, metadata, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_population_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_population_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_population_table_equals(&t1, &source, 0));\n\n ret = tsk_population_table_keep_rows(&t1, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_population_table_equals(&t1, &source, 0));\n CU_ASSERT_EQUAL_FATAL(id_map[0], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], 2);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n ret = tsk_population_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_population_table_copy(&source, &t1, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[0] = 0;\n keep[1] = 1;\n keep[2] = 0;\n ret = tsk_population_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 1);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_population_table_get_row(&t1, 0, &row);\n CU_ASSERT_EQUAL_FATAL(row.metadata_length, 2);\n CU_ASSERT_EQUAL_FATAL(row.metadata[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.metadata[1], 'B');\n\n tsk_population_table_free(&t1);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n /* Keeping first n rows equivalent to truncate */\n for (j = 0; j < source.num_rows; j++) {\n ret = tsk_population_table_copy(&source, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_population_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_population_table_truncate(&t1, j + 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[j] = 1;\n ret = tsk_population_table_keep_rows(&t2, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_population_table_equals(&t1, &t2, 0));\n\n /* Adding the remaining rows back on to the table gives the original\n * table */\n ret = tsk_population_table_extend(\n &t2, &source, source.num_rows - j - 1, indexes + j + 1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_population_table_equals(&source, &t2, 0));\n\n tsk_population_table_free(&t1);\n tsk_population_table_free(&t2);\n }\n\n tsk_population_table_free(&source);\n}\n\nstatic void\ntest_provenance_table(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_provenance_table_t table, table2;\n tsk_size_t num_rows = 100;\n tsk_size_t j;\n char *timestamp;\n tsk_size_t *timestamp_offset;\n const char *test_timestamp = \"2017-12-06T20:40:25+00:00\";\n tsk_size_t test_timestamp_length = (tsk_size_t) strlen(test_timestamp);\n char timestamp_copy[test_timestamp_length + 1];\n char *record;\n tsk_size_t *record_offset;\n const char *test_record = \"{\\\"json\\\"=1234}\";\n tsk_size_t test_record_length = (tsk_size_t) strlen(test_record);\n char record_copy[test_record_length + 1];\n tsk_provenance_t provenance, provenance2;\n tsk_id_t row_subset[6] = { 1, 9, 1, 0, 2, 2 };\n tsk_size_t num_row_subset = 6;\n\n timestamp_copy[test_timestamp_length] = '\\0';\n record_copy[test_record_length] = '\\0';\n ret = tsk_provenance_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_provenance_table_set_max_rows_increment(&table, 1);\n tsk_provenance_table_set_max_timestamp_length_increment(&table, 1);\n tsk_provenance_table_set_max_record_length_increment(&table, 1);\n tsk_provenance_table_print_state(&table, _devnull);\n ret = tsk_provenance_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = 0; j < num_rows; j++) {\n ret_id = tsk_provenance_table_add_row(&table, test_timestamp,\n test_timestamp_length, test_record, test_record_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, (tsk_id_t) j);\n CU_ASSERT_EQUAL(table.timestamp_length, (j + 1) * test_timestamp_length);\n CU_ASSERT_EQUAL(table.timestamp_offset[j + 1], table.timestamp_length);\n CU_ASSERT_EQUAL(table.record_length, (j + 1) * test_record_length);\n CU_ASSERT_EQUAL(table.record_offset[j + 1], table.record_length);\n /* check the timestamp */\n tsk_memcpy(timestamp_copy, table.timestamp + table.timestamp_offset[j],\n test_timestamp_length);\n CU_ASSERT_NSTRING_EQUAL(timestamp_copy, test_timestamp, test_timestamp_length);\n /* check the record */\n tsk_memcpy(\n record_copy, table.record + table.record_offset[j], test_record_length);\n CU_ASSERT_NSTRING_EQUAL(record_copy, test_record, test_record_length);\n\n ret = tsk_provenance_table_get_row(&table, (tsk_id_t) j, &provenance);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(provenance.id, (tsk_id_t) j);\n CU_ASSERT_EQUAL(provenance.timestamp_length, test_timestamp_length);\n CU_ASSERT_NSTRING_EQUAL(\n provenance.timestamp, test_timestamp, test_timestamp_length);\n CU_ASSERT_EQUAL(provenance.record_length, test_record_length);\n CU_ASSERT_NSTRING_EQUAL(provenance.record, test_record, test_record_length);\n }\n ret = tsk_provenance_table_get_row(&table, (tsk_id_t) num_rows, &provenance);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_PROVENANCE_OUT_OF_BOUNDS);\n tsk_provenance_table_print_state(&table, _devnull);\n ret = tsk_provenance_table_dump_text(&table, _devnull);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_provenance_table_clear(&table);\n CU_ASSERT_EQUAL(table.num_rows, 0);\n CU_ASSERT_EQUAL(table.timestamp_length, 0);\n CU_ASSERT_EQUAL(table.record_length, 0);\n\n num_rows *= 2;\n timestamp = tsk_malloc(num_rows * sizeof(char));\n tsk_memset(timestamp, 'a', num_rows * sizeof(char));\n CU_ASSERT_FATAL(timestamp != NULL);\n timestamp_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(timestamp_offset != NULL);\n record = tsk_malloc(num_rows * sizeof(char));\n tsk_memset(record, 'a', num_rows * sizeof(char));\n CU_ASSERT_FATAL(record != NULL);\n record_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(record_offset != NULL);\n for (j = 0; j < num_rows + 1; j++) {\n timestamp_offset[j] = j;\n record_offset[j] = j;\n }\n ret = tsk_provenance_table_set_columns(\n &table, num_rows, timestamp, timestamp_offset, record, record_offset);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.timestamp, timestamp, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.timestamp_offset, timestamp_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.record, record, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.record_offset, record_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.timestamp_length, num_rows);\n CU_ASSERT_EQUAL(table.record_length, num_rows);\n tsk_provenance_table_print_state(&table, _devnull);\n\n /* Append another num_rows onto the end */\n ret = tsk_provenance_table_append_columns(\n &table, num_rows, timestamp, timestamp_offset, record, record_offset);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.timestamp, timestamp, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.timestamp + num_rows, timestamp, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.record, record, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(table.record + num_rows, record, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(table.num_rows, 2 * num_rows);\n CU_ASSERT_EQUAL(table.timestamp_length, 2 * num_rows);\n CU_ASSERT_EQUAL(table.record_length, 2 * num_rows);\n tsk_provenance_table_print_state(&table, _devnull);\n\n /* Truncate back to num_rows */\n ret = tsk_provenance_table_truncate(&table, num_rows);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.timestamp, timestamp, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.timestamp_offset, timestamp_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.record, record, num_rows * sizeof(char)), 0);\n CU_ASSERT_EQUAL(tsk_memcmp(table.record_offset, record_offset,\n (num_rows + 1) * sizeof(tsk_size_t)),\n 0);\n CU_ASSERT_EQUAL(table.num_rows, num_rows);\n CU_ASSERT_EQUAL(table.timestamp_length, num_rows);\n CU_ASSERT_EQUAL(table.record_length, num_rows);\n tsk_provenance_table_print_state(&table, _devnull);\n\n /* Test equality with and without timestamp */\n tsk_provenance_table_copy(&table, &table2, 0);\n CU_ASSERT_TRUE(tsk_provenance_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(\n tsk_provenance_table_equals(&table, &table2, TSK_CMP_IGNORE_TIMESTAMPS));\n /* Change the timestamp values */\n table2.timestamp[0] = 0;\n CU_ASSERT_FALSE(tsk_provenance_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(\n tsk_provenance_table_equals(&table, &table2, TSK_CMP_IGNORE_TIMESTAMPS));\n /* Change the last timestamp entry */\n table2.timestamp_offset[table2.num_rows]\n = table2.timestamp_offset[table2.num_rows - 1];\n CU_ASSERT_FALSE(tsk_provenance_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(\n tsk_provenance_table_equals(&table, &table2, TSK_CMP_IGNORE_TIMESTAMPS));\n /* Delete all timestamps */\n tsk_memset(table2.timestamp_offset, 0,\n (table2.num_rows + 1) * sizeof(*table2.timestamp_offset));\n CU_ASSERT_FALSE(tsk_provenance_table_equals(&table, &table2, 0));\n CU_ASSERT_TRUE(\n tsk_provenance_table_equals(&table, &table2, TSK_CMP_IGNORE_TIMESTAMPS));\n tsk_provenance_table_free(&table2);\n\n /* Test equality with and without timestamp */\n tsk_provenance_table_copy(&table, &table2, 0);\n table2.record_length = 0;\n CU_ASSERT_FALSE(tsk_provenance_table_equals(&table, &table2, 0));\n tsk_provenance_table_free(&table2);\n\n ret = tsk_provenance_table_truncate(&table, num_rows + 1);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_TABLE_POSITION);\n\n /* No arguments can be null */\n ret = tsk_provenance_table_set_columns(\n &table, num_rows, NULL, timestamp_offset, record, record_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_provenance_table_set_columns(\n &table, num_rows, timestamp, NULL, record, record_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_provenance_table_set_columns(\n &table, num_rows, timestamp, timestamp_offset, NULL, record_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_provenance_table_set_columns(\n &table, num_rows, timestamp, timestamp_offset, record, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* Test extend method */\n ret = tsk_provenance_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_provenance_table_init(&table2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Can't extend from self */\n ret = tsk_provenance_table_extend(&table, &table, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n\n /* Two empty tables */\n CU_ASSERT_TRUE(tsk_provenance_table_equals(&table, &table2, 0));\n ret = tsk_provenance_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_provenance_table_equals(&table, &table2, 0));\n\n /* Row out of bounds */\n ret = tsk_provenance_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_PROVENANCE_OUT_OF_BOUNDS);\n\n /* Num rows out of bounds */\n ret = tsk_provenance_table_extend(&table, &table2, num_rows * 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_PROVENANCE_OUT_OF_BOUNDS);\n\n /* Copy rows in order if index NULL */\n ret = tsk_provenance_table_set_columns(\n &table2, num_rows, timestamp, timestamp_offset, record, record_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_provenance_table_equals(&table, &table2, 0));\n ret = tsk_provenance_table_extend(&table, &table2, table2.num_rows, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_provenance_table_equals(&table, &table2, 0));\n\n /* Copy nothing if index not NULL but length zero */\n ret = tsk_provenance_table_extend(&table, &table2, 0, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_provenance_table_equals(&table, &table2, 0));\n\n /* Copy first N rows in order if index NULL */\n ret = tsk_provenance_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_provenance_table_extend(&table, &table2, num_rows / 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_provenance_table_truncate(&table2, num_rows / 2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_provenance_table_equals(&table, &table2, 0));\n ret = tsk_provenance_table_set_columns(\n &table2, num_rows, timestamp, timestamp_offset, record, record_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Copy a subset */\n ret = tsk_provenance_table_truncate(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_provenance_table_equals(&table, &table2, 0));\n ret = tsk_provenance_table_extend(&table, &table2, num_row_subset, row_subset, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < num_row_subset; j++) {\n ret = tsk_provenance_table_get_row(&table, (tsk_id_t) j, &provenance);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_provenance_table_get_row(&table2, row_subset[j], &provenance2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(provenance.timestamp_length, provenance2.timestamp_length);\n CU_ASSERT_EQUAL(provenance.record_length, provenance2.record_length);\n CU_ASSERT_EQUAL(tsk_memcmp(provenance.timestamp, provenance2.timestamp,\n provenance.timestamp_length * sizeof(*provenance.timestamp)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(provenance.record, provenance2.record,\n provenance.record_length * sizeof(*provenance.record)),\n 0);\n }\n\n tsk_provenance_table_free(&table);\n tsk_provenance_table_free(&table2);\n free(timestamp);\n free(timestamp_offset);\n free(record);\n free(record_offset);\n}\n\nstatic void\ntest_provenance_table_takeset(void)\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_provenance_table_t source_table, table;\n tsk_size_t num_rows = 100;\n tsk_id_t j;\n char *timestamp;\n tsk_size_t *timestamp_offset;\n char *record;\n tsk_size_t *record_offset;\n const char *test_timestamp = \"red\";\n tsk_size_t test_timestamp_length = 3;\n const char *test_record = \"test\";\n tsk_size_t test_record_length = 4;\n tsk_size_t zeros[num_rows + 1];\n tsk_id_t neg_ones[num_rows];\n\n tsk_memset(zeros, 0, (num_rows + 1) * sizeof(tsk_size_t));\n tsk_memset(neg_ones, 0xff, num_rows * sizeof(tsk_id_t));\n /* Make a table to copy from */\n ret = tsk_provenance_table_init(&source_table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < (tsk_id_t) num_rows; j++) {\n ret_id = tsk_provenance_table_add_row(&source_table, test_timestamp,\n test_timestamp_length, test_record, test_record_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n }\n\n /* Prepare arrays to be taken */\n timestamp = tsk_malloc(num_rows * test_timestamp_length * sizeof(char));\n CU_ASSERT_FATAL(timestamp != NULL);\n tsk_memcpy(timestamp, source_table.timestamp,\n num_rows * test_timestamp_length * sizeof(char));\n timestamp_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(timestamp_offset != NULL);\n tsk_memcpy(timestamp_offset, source_table.timestamp_offset,\n (num_rows + 1) * sizeof(tsk_size_t));\n record = tsk_malloc(num_rows * test_record_length * sizeof(char));\n CU_ASSERT_FATAL(record != NULL);\n tsk_memcpy(\n record, source_table.record, num_rows * test_record_length * sizeof(char));\n record_offset = tsk_malloc((num_rows + 1) * sizeof(tsk_size_t));\n CU_ASSERT_FATAL(record_offset != NULL);\n tsk_memcpy(\n record_offset, source_table.record_offset, (num_rows + 1) * sizeof(tsk_size_t));\n\n ret = tsk_provenance_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Add one row so that we can check takeset frees it */\n ret_id = tsk_provenance_table_add_row(\n &table, test_timestamp, test_timestamp_length, test_record, test_record_length);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n ret = tsk_provenance_table_takeset_columns(\n &table, num_rows, timestamp, timestamp_offset, record, record_offset);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_provenance_table_equals(&source_table, &table, 0));\n\n /* Test error states, all of these must not take the array, or free existing */\n ret = tsk_provenance_table_takeset_columns(\n &table, num_rows, NULL, timestamp_offset, record, record_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_provenance_table_takeset_columns(\n &table, num_rows, timestamp, NULL, record, record_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_provenance_table_takeset_columns(\n &table, num_rows, timestamp, timestamp_offset, NULL, record_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_provenance_table_takeset_columns(\n &table, num_rows, timestamp, timestamp_offset, record, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* Bad offsets */\n timestamp_offset[0] = 1;\n ret = tsk_provenance_table_takeset_columns(\n &table, num_rows, timestamp, timestamp_offset, record, record_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n timestamp_offset[0] = 0;\n record_offset[0] = 1;\n ret = tsk_provenance_table_takeset_columns(\n &table, num_rows, timestamp, timestamp_offset, record, record_offset);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n\n /* Truncation after takeset keeps memory and max_rows */\n ret = tsk_provenance_table_clear(&table);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(table.max_rows, num_rows);\n\n ret = tsk_provenance_table_free(&table);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_provenance_table_free(&source_table);\n CU_ASSERT_EQUAL(ret, 0);\n}\n\nstatic void\ntest_provenance_table_update_row(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_provenance_table_t table;\n tsk_provenance_t row;\n const char *timestamp = \"XYZ\";\n const char *record = \"ABC\";\n\n ret = tsk_provenance_table_init(&table, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_provenance_table_add_row(&table, timestamp, 1, record, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_provenance_table_add_row(&table, timestamp, 2, record, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_provenance_table_add_row(&table, timestamp, 3, record, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_provenance_table_update_row(&table, 0, ×tamp[1], 1, &record[1], 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_provenance_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.timestamp_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.timestamp[0], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.record_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.record[0], 'B');\n\n ret = tsk_provenance_table_update_row(\n &table, 0, row.timestamp, row.timestamp_length, row.record, row.record_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_provenance_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.timestamp_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.timestamp[0], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.record_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.record[0], 'B');\n\n ret = tsk_provenance_table_update_row(&table, 0, row.timestamp,\n row.timestamp_length - 1, row.record, row.record_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_provenance_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.timestamp_length, 0);\n CU_ASSERT_EQUAL_FATAL(row.record_length, 1);\n CU_ASSERT_EQUAL_FATAL(row.record[0], 'B');\n\n ret = tsk_provenance_table_update_row(&table, 0, timestamp, 3, record, 3);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_provenance_table_get_row(&table, 0, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.timestamp_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.timestamp[0], 'X');\n CU_ASSERT_EQUAL_FATAL(row.timestamp[1], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.timestamp[2], 'Z');\n CU_ASSERT_EQUAL_FATAL(row.record_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.record[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.record[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.record[2], 'C');\n\n ret = tsk_provenance_table_update_row(&table, 1, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_provenance_table_get_row(&table, 1, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.timestamp_length, 0);\n CU_ASSERT_EQUAL_FATAL(row.record_length, 0);\n\n ret = tsk_provenance_table_get_row(&table, 2, &row);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(row.timestamp_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.timestamp[0], 'X');\n CU_ASSERT_EQUAL_FATAL(row.timestamp[1], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.timestamp[2], 'Z');\n CU_ASSERT_EQUAL_FATAL(row.record_length, 3);\n CU_ASSERT_EQUAL_FATAL(row.record[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.record[1], 'B');\n CU_ASSERT_EQUAL_FATAL(row.record[2], 'C');\n\n ret = tsk_provenance_table_update_row(&table, 3, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_PROVENANCE_OUT_OF_BOUNDS);\n\n tsk_provenance_table_free(&table);\n}\n\nstatic void\ntest_provenance_table_keep_rows(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_provenance_table_t source, t1, t2;\n tsk_provenance_t row;\n const char *timestamp = \"XYZ\";\n const char *record = \"ABC\";\n tsk_bool_t keep[3] = { 1, 1, 1 };\n tsk_id_t indexes[] = { 0, 1, 2 };\n tsk_id_t id_map[3];\n\n ret = tsk_provenance_table_init(&source, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_provenance_table_add_row(&source, timestamp, 1, record, 1);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_provenance_table_add_row(&source, timestamp, 2, record, 2);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_provenance_table_add_row(&source, timestamp, 3, record, 3);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_provenance_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_provenance_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_provenance_table_equals(&t1, &source, 0));\n\n ret = tsk_provenance_table_keep_rows(&t1, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_provenance_table_equals(&t1, &source, 0));\n CU_ASSERT_EQUAL_FATAL(id_map[0], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], 2);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n ret = tsk_provenance_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_provenance_table_copy(&source, &t1, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[0] = 0;\n keep[1] = 1;\n keep[2] = 0;\n ret = tsk_provenance_table_keep_rows(&t1, keep, 0, id_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t1.num_rows, 1);\n CU_ASSERT_EQUAL_FATAL(id_map[0], -1);\n CU_ASSERT_EQUAL_FATAL(id_map[1], 0);\n CU_ASSERT_EQUAL_FATAL(id_map[2], -1);\n\n ret = tsk_provenance_table_get_row(&t1, 0, &row);\n CU_ASSERT_EQUAL_FATAL(row.timestamp_length, 2);\n CU_ASSERT_EQUAL_FATAL(row.timestamp[0], 'X');\n CU_ASSERT_EQUAL_FATAL(row.timestamp[1], 'Y');\n CU_ASSERT_EQUAL_FATAL(row.record_length, 2);\n CU_ASSERT_EQUAL_FATAL(row.record[0], 'A');\n CU_ASSERT_EQUAL_FATAL(row.record[1], 'B');\n\n tsk_provenance_table_free(&t1);\n\n keep[0] = 0;\n keep[1] = 0;\n keep[2] = 0;\n /* Keeping first n rows equivalent to truncate */\n for (j = 0; j < source.num_rows; j++) {\n ret = tsk_provenance_table_copy(&source, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_provenance_table_copy(&source, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_provenance_table_truncate(&t1, j + 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n keep[j] = 1;\n ret = tsk_provenance_table_keep_rows(&t2, keep, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_provenance_table_equals(&t1, &t2, 0));\n\n /* Adding the remaining rows back on to the table gives the original\n * table */\n ret = tsk_provenance_table_extend(\n &t2, &source, source.num_rows - j - 1, indexes + j + 1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_provenance_table_equals(&source, &t2, 0));\n\n tsk_provenance_table_free(&t1);\n tsk_provenance_table_free(&t2);\n }\n\n tsk_provenance_table_free(&source);\n}\n\nstatic void\ntest_table_size_increments(void)\n{\n int ret;\n tsk_table_collection_t tables;\n tsk_size_t new_size;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_rows_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_metadata_length_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_location_length_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_rows_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.edges.max_rows_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.edges.max_metadata_length_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_rows_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_metadata_length_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_ancestral_state_length_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_rows_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_metadata_length_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_derived_state_length_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.migrations.max_rows_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.migrations.max_metadata_length_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.populations.max_rows_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.populations.max_metadata_length_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_rows_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_timestamp_length_increment, 0);\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_record_length_increment, 0);\n\n /* Setting to non-zero sets to that size */\n new_size = 1;\n ret = tsk_individual_table_set_max_rows_increment(&tables.individuals, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_rows_increment, new_size);\n ret = tsk_individual_table_set_max_metadata_length_increment(\n &tables.individuals, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_metadata_length_increment, new_size);\n ret = tsk_individual_table_set_max_location_length_increment(\n &tables.individuals, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_location_length_increment, new_size);\n\n ret = tsk_node_table_set_max_rows_increment(&tables.nodes, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_rows_increment, new_size);\n ret = tsk_node_table_set_max_metadata_length_increment(&tables.nodes, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length_increment, new_size);\n\n ret = tsk_edge_table_set_max_rows_increment(&tables.edges, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.edges.max_rows_increment, new_size);\n ret = tsk_edge_table_set_max_metadata_length_increment(&tables.edges, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.edges.max_metadata_length_increment, new_size);\n\n ret = tsk_site_table_set_max_rows_increment(&tables.sites, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_rows_increment, new_size);\n ret = tsk_site_table_set_max_metadata_length_increment(&tables.sites, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_metadata_length_increment, new_size);\n ret = tsk_site_table_set_max_ancestral_state_length_increment(\n &tables.sites, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_ancestral_state_length_increment, new_size);\n\n ret = tsk_mutation_table_set_max_rows_increment(&tables.mutations, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_rows_increment, new_size);\n ret = tsk_mutation_table_set_max_metadata_length_increment(\n &tables.mutations, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_metadata_length_increment, new_size);\n ret = tsk_mutation_table_set_max_derived_state_length_increment(\n &tables.mutations, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_derived_state_length_increment, new_size);\n\n ret = tsk_migration_table_set_max_rows_increment(&tables.migrations, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.migrations.max_rows_increment, new_size);\n ret = tsk_migration_table_set_max_metadata_length_increment(\n &tables.migrations, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.migrations.max_metadata_length_increment, new_size);\n\n ret = tsk_population_table_set_max_rows_increment(&tables.populations, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.populations.max_rows_increment, new_size);\n ret = tsk_population_table_set_max_metadata_length_increment(\n &tables.populations, new_size);\n CU_ASSERT_EQUAL_FATAL(tables.populations.max_metadata_length_increment, new_size);\n\n ret = tsk_provenance_table_set_max_rows_increment(&tables.provenances, new_size);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_rows_increment, new_size);\n ret = tsk_provenance_table_set_max_timestamp_length_increment(\n &tables.provenances, new_size);\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_timestamp_length_increment, new_size);\n ret = tsk_provenance_table_set_max_record_length_increment(\n &tables.provenances, new_size);\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_record_length_increment, new_size);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_table_expansion(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n tsk_table_collection_t tables2;\n\n ret = tsk_table_collection_init(&tables2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Individual table */\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_rows, 1);\n\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /*Extending by a small amount results in 1024 rows in the first case*/\n ret = tsk_individual_table_extend(\n &tables.individuals, &tables2.individuals, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_rows, 1024);\n\n /*Extending by an amount that fits doesn't grow the table*/\n ret = tsk_individual_table_extend(\n &tables.individuals, &tables2.individuals, 1023, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_rows, 1024);\n\n /*Extending by an amount that doesn't fit doubles the table*/\n ret = tsk_individual_table_extend(\n &tables.individuals, &tables2.individuals, 1024, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_rows, 2048);\n\n /*Extending by an amount greater than the next double extends to that amount*/\n ret = tsk_individual_table_extend(\n &tables.individuals, &tables2.individuals, 4096, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_rows, 4097);\n\n /*After extending beyond 2^21 subsequent extension doesn't double but adds 2^21*/\n ret = tsk_individual_table_extend(\n &tables.individuals, &tables2.individuals, 2097152, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_rows, 2097153);\n ret = tsk_individual_table_extend(\n &tables.individuals, &tables2.individuals, 2097154, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_rows, 4194305);\n\n /*Extending by more rows than possible results in overflow*/\n ret = tsk_individual_table_extend(\n &tables.individuals, &tables2.individuals, TSK_MAX_ID, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_rows, 4194305);\n\n /*Setting a custom extension uses that*/\n ret = tsk_individual_table_set_max_rows_increment(&tables.individuals, 42);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_individual_table_extend(\n &tables.individuals, &tables2.individuals, 4194305, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_rows, 4194305 + 42);\n\n /*Setting a custom extension that overflows errors*/\n ret = tsk_individual_table_set_max_rows_increment(&tables.individuals, TSK_MAX_ID);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_individual_table_extend(\n &tables.individuals, &tables2.individuals, 4194305 + 42 + 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.max_rows, 4194305 + 42);\n\n tsk_table_collection_free(&tables);\n\n /* Node table */\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_rows, 1);\n\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /*Extending by a small amount results in 1024 rows in the first case*/\n ret = tsk_node_table_extend(&tables.nodes, &tables2.nodes, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_rows, 1024);\n\n /*Extending by an amount that fits doesn't grow the table*/\n ret = tsk_node_table_extend(&tables.nodes, &tables2.nodes, 1023, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_rows, 1024);\n\n /*Extending by an amount that doesn't fit doubles the table*/\n ret = tsk_node_table_extend(&tables.nodes, &tables2.nodes, 1024, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_rows, 2048);\n\n /*Extending by an amount greater than the next double extends to that amount*/\n ret = tsk_node_table_extend(&tables.nodes, &tables2.nodes, 4096, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_rows, 4097);\n\n /*After extending beyond 2^21 subsequent extension doesn't double but adds 2^21*/\n ret = tsk_node_table_extend(&tables.nodes, &tables2.nodes, 2097152, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_rows, 2097153);\n ret = tsk_node_table_extend(&tables.nodes, &tables2.nodes, 2097154, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_rows, 4194305);\n\n /*Extending by more rows than possible results in overflow*/\n ret = tsk_node_table_extend(&tables.nodes, &tables2.nodes, TSK_MAX_ID, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_rows, 4194305);\n\n /*Setting a custom extension uses that*/\n ret = tsk_node_table_set_max_rows_increment(&tables.nodes, 42);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_node_table_extend(&tables.nodes, &tables2.nodes, 4194305, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_rows, 4194305 + 42);\n\n /*Setting a custom extension that overflows errors*/\n ret = tsk_node_table_set_max_rows_increment(&tables.nodes, TSK_MAX_ID);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_node_table_extend(\n &tables.nodes, &tables2.nodes, 4194305 + 42 + 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_rows, 4194305 + 42);\n\n tsk_table_collection_free(&tables);\n\n /* Edge table */\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(tables.edges.max_rows, 1);\n\n ret_id = tsk_edge_table_add_row(&tables.edges, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /*Extending by a small amount results in 1024 rows in the first case*/\n ret = tsk_edge_table_extend(&tables.edges, &tables2.edges, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.edges.max_rows, 1024);\n\n /*Extending by an amount that fits doesn't grow the table*/\n ret = tsk_edge_table_extend(&tables.edges, &tables2.edges, 1023, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.edges.max_rows, 1024);\n\n /*Extending by an amount that doesn't fit doubles the table*/\n ret = tsk_edge_table_extend(&tables.edges, &tables2.edges, 1024, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.edges.max_rows, 2048);\n\n /*Extending by an amount greater than the next double extends to that amount*/\n ret = tsk_edge_table_extend(&tables.edges, &tables2.edges, 4096, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.edges.max_rows, 4097);\n\n /*After extending beyond 2^21 subsequent extension doesn't double but adds 2^21*/\n ret = tsk_edge_table_extend(&tables.edges, &tables2.edges, 2097152, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.edges.max_rows, 2097153);\n ret = tsk_edge_table_extend(&tables.edges, &tables2.edges, 2097154, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.edges.max_rows, 4194305);\n\n /*Extending by more rows than possible results in overflow*/\n ret = tsk_edge_table_extend(&tables.edges, &tables2.edges, TSK_MAX_ID, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.edges.max_rows, 4194305);\n\n /*Setting a custom extension uses that*/\n ret = tsk_edge_table_set_max_rows_increment(&tables.edges, 42);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_edge_table_extend(&tables.edges, &tables2.edges, 4194305, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.edges.max_rows, 4194305 + 42);\n\n /*Setting a custom extension that overflows errors*/\n ret = tsk_edge_table_set_max_rows_increment(&tables.edges, TSK_MAX_ID);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_extend(\n &tables.edges, &tables2.edges, 4194305 + 42 + 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.edges.max_rows, 4194305 + 42);\n\n tsk_table_collection_free(&tables);\n\n /* Migration table */\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(tables.migrations.max_rows, 1);\n\n ret_id = tsk_migration_table_add_row(&tables.migrations, 0, 0, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /*Extending by a small amount results in 1024 rows in the first case*/\n ret = tsk_migration_table_extend(\n &tables.migrations, &tables2.migrations, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.migrations.max_rows, 1024);\n\n /*Extending by an amount that fits doesn't grow the table*/\n ret = tsk_migration_table_extend(\n &tables.migrations, &tables2.migrations, 1023, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.migrations.max_rows, 1024);\n\n /*Extending by an amount that doesn't fit doubles the table*/\n ret = tsk_migration_table_extend(\n &tables.migrations, &tables2.migrations, 1024, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.migrations.max_rows, 2048);\n\n /*Extending by an amount greater than the next double extends to that amount*/\n ret = tsk_migration_table_extend(\n &tables.migrations, &tables2.migrations, 4096, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.migrations.max_rows, 4097);\n\n /*After extending beyond 2^21 subsequent extension doesn't double but adds 2^21*/\n ret = tsk_migration_table_extend(\n &tables.migrations, &tables2.migrations, 2097152, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.migrations.max_rows, 2097153);\n ret = tsk_migration_table_extend(\n &tables.migrations, &tables2.migrations, 2097154, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.migrations.max_rows, 4194305);\n\n /*Extending by more rows than possible results in overflow*/\n ret = tsk_migration_table_extend(\n &tables.migrations, &tables2.migrations, TSK_MAX_ID, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.migrations.max_rows, 4194305);\n\n /*Setting a custom extension uses that*/\n ret = tsk_migration_table_set_max_rows_increment(&tables.migrations, 42);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_migration_table_extend(\n &tables.migrations, &tables2.migrations, 4194305, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.migrations.max_rows, 4194305 + 42);\n\n /*Setting a custom extension that overflows errors*/\n ret = tsk_migration_table_set_max_rows_increment(&tables.migrations, TSK_MAX_ID);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_migration_table_extend(\n &tables.migrations, &tables2.migrations, 4194305 + 42 + 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.migrations.max_rows, 4194305 + 42);\n\n tsk_table_collection_free(&tables);\n\n /* Site table */\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_rows, 1);\n\n ret_id = tsk_site_table_add_row(&tables.sites, 0, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /*Extending by a small amount results in 1024 rows in the first case*/\n ret = tsk_site_table_extend(&tables.sites, &tables2.sites, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_rows, 1024);\n\n /*Extending by an amount that fits doesn't grow the table*/\n ret = tsk_site_table_extend(&tables.sites, &tables2.sites, 1023, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_rows, 1024);\n\n /*Extending by an amount that doesn't fit doubles the table*/\n ret = tsk_site_table_extend(&tables.sites, &tables2.sites, 1024, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_rows, 2048);\n\n /*Extending by an amount greater than the next double extends to that amount*/\n ret = tsk_site_table_extend(&tables.sites, &tables2.sites, 4096, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_rows, 4097);\n\n /*After extending beyond 2^21 subsequent extension doesn't double but adds 2^21*/\n ret = tsk_site_table_extend(&tables.sites, &tables2.sites, 2097152, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_rows, 2097153);\n ret = tsk_site_table_extend(&tables.sites, &tables2.sites, 2097154, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_rows, 4194305);\n\n /*Extending by more rows than possible results in overflow*/\n ret = tsk_site_table_extend(&tables.sites, &tables2.sites, TSK_MAX_ID, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_rows, 4194305);\n\n /*Setting a custom extension uses that*/\n ret = tsk_site_table_set_max_rows_increment(&tables.sites, 42);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_site_table_extend(&tables.sites, &tables2.sites, 4194305, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_rows, 4194305 + 42);\n\n /*Setting a custom extension that overflows errors*/\n ret = tsk_site_table_set_max_rows_increment(&tables.sites, TSK_MAX_ID);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_site_table_extend(\n &tables.sites, &tables2.sites, 4194305 + 42 + 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.sites.max_rows, 4194305 + 42);\n\n tsk_table_collection_free(&tables);\n\n /* Mutation table */\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_rows, 1);\n\n ret_id = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 0, 0, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /*Extending by a small amount results in 1024 rows in the first case*/\n ret = tsk_mutation_table_extend(&tables.mutations, &tables2.mutations, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_rows, 1024);\n\n /*Extending by an amount that fits doesn't grow the table*/\n ret = tsk_mutation_table_extend(\n &tables.mutations, &tables2.mutations, 1023, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_rows, 1024);\n\n /*Extending by an amount that doesn't fit doubles the table*/\n ret = tsk_mutation_table_extend(\n &tables.mutations, &tables2.mutations, 1024, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_rows, 2048);\n\n /*Extending by an amount greater than the next double extends to that amount*/\n ret = tsk_mutation_table_extend(\n &tables.mutations, &tables2.mutations, 4096, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_rows, 4097);\n\n /*After extending beyond 2^21 subsequent extension doesn't double but adds 2^21*/\n ret = tsk_mutation_table_extend(\n &tables.mutations, &tables2.mutations, 2097152, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_rows, 2097153);\n ret = tsk_mutation_table_extend(\n &tables.mutations, &tables2.mutations, 2097154, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_rows, 4194305);\n\n /*Extending by more rows than possible results in overflow*/\n ret = tsk_mutation_table_extend(\n &tables.mutations, &tables2.mutations, TSK_MAX_ID, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_rows, 4194305);\n\n /*Setting a custom extension uses that*/\n ret = tsk_mutation_table_set_max_rows_increment(&tables.mutations, 42);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_mutation_table_extend(\n &tables.mutations, &tables2.mutations, 4194305, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_rows, 4194305 + 42);\n\n /*Setting a custom extension that overflows errors*/\n ret = tsk_mutation_table_set_max_rows_increment(&tables.mutations, TSK_MAX_ID);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_mutation_table_extend(\n &tables.mutations, &tables2.mutations, 4194305 + 42 + 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.max_rows, 4194305 + 42);\n\n tsk_table_collection_free(&tables);\n\n /* Population table */\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(tables.populations.max_rows, 1);\n\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /*Extending by a small amount results in 1024 rows in the first case*/\n ret = tsk_population_table_extend(\n &tables.populations, &tables2.populations, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.populations.max_rows, 1024);\n\n /*Extending by an amount that fits doesn't grow the table*/\n ret = tsk_population_table_extend(\n &tables.populations, &tables2.populations, 1023, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.populations.max_rows, 1024);\n\n /*Extending by an amount that doesn't fit doubles the table*/\n ret = tsk_population_table_extend(\n &tables.populations, &tables2.populations, 1024, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.populations.max_rows, 2048);\n\n /*Extending by an amount greater than the next double extends to that amount*/\n ret = tsk_population_table_extend(\n &tables.populations, &tables2.populations, 4096, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.populations.max_rows, 4097);\n\n /*After extending beyond 2^21 subsequent extension doesn't double but adds 2^21*/\n ret = tsk_population_table_extend(\n &tables.populations, &tables2.populations, 2097152, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.populations.max_rows, 2097153);\n ret = tsk_population_table_extend(\n &tables.populations, &tables2.populations, 2097154, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.populations.max_rows, 4194305);\n\n /*Extending by more rows than possible results in overflow*/\n ret = tsk_population_table_extend(\n &tables.populations, &tables2.populations, TSK_MAX_ID, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.populations.max_rows, 4194305);\n\n /*Setting a custom extension uses that*/\n ret = tsk_population_table_set_max_rows_increment(&tables.populations, 42);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_population_table_extend(\n &tables.populations, &tables2.populations, 4194305, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.populations.max_rows, 4194305 + 42);\n\n /*Setting a custom extension that overflows errors*/\n ret = tsk_population_table_set_max_rows_increment(&tables.populations, TSK_MAX_ID);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_population_table_extend(\n &tables.populations, &tables2.populations, 4194305 + 42 + 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.populations.max_rows, 4194305 + 42);\n\n tsk_table_collection_free(&tables);\n\n /* Provenance table */\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_rows, 1);\n\n ret_id = tsk_provenance_table_add_row(&tables.provenances, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /*Extending by a small amount results in 1024 rows in the first case*/\n ret = tsk_provenance_table_extend(\n &tables.provenances, &tables2.provenances, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_PROVENANCE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_rows, 1024);\n\n /*Extending by an amount that fits doesn't grow the table*/\n ret = tsk_provenance_table_extend(\n &tables.provenances, &tables2.provenances, 1023, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_PROVENANCE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_rows, 1024);\n\n /*Extending by an amount that doesn't fit doubles the table*/\n ret = tsk_provenance_table_extend(\n &tables.provenances, &tables2.provenances, 1024, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_PROVENANCE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_rows, 2048);\n\n /*Extending by an amount greater than the next double extends to that amount*/\n ret = tsk_provenance_table_extend(\n &tables.provenances, &tables2.provenances, 4096, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_PROVENANCE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_rows, 4097);\n\n /*After extending beyond 2^21 subsequent extension doesn't double but adds 2^21*/\n ret = tsk_provenance_table_extend(\n &tables.provenances, &tables2.provenances, 2097152, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_rows, 2097153);\n ret = tsk_provenance_table_extend(\n &tables.provenances, &tables2.provenances, 2097154, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_rows, 4194305);\n\n /*Extending by more rows than possible results in overflow*/\n ret = tsk_provenance_table_extend(\n &tables.provenances, &tables2.provenances, TSK_MAX_ID, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_rows, 4194305);\n\n /*Setting a custom extension uses that*/\n ret = tsk_provenance_table_set_max_rows_increment(&tables.provenances, 42);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_provenance_table_extend(\n &tables.provenances, &tables2.provenances, 4194305, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_PROVENANCE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_rows, 4194305 + 42);\n\n /*Setting a custom extension that overflows errors*/\n ret = tsk_provenance_table_set_max_rows_increment(&tables.provenances, TSK_MAX_ID);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_provenance_table_extend(\n &tables.provenances, &tables2.provenances, 4194305 + 42 + 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLE_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.provenances.max_rows, 4194305 + 42);\n\n tsk_table_collection_free(&tables);\n tsk_table_collection_free(&tables2);\n}\n\nstatic void\ntest_ragged_expansion(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n char *data = tsk_malloc(104857600 * sizeof(char));\n\n /* Test with node table metadata */\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 1);\n\n /*Extending by a small amount results in 65536 bytes in the first case*/\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, 2);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 65536);\n\n /*Extending by an amount that fits doesn't grow the column*/\n ret_id\n = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, 65534);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 65536);\n\n /*Extending by an amount that doesn't fit doubles the column*/\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, 2);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 65536 * 2);\n\n /*Extending by an amount greater than the next double extends to that amount*/\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data,\n 1 + (65536 * 2 * 2 - 2 - 65534 - 1));\n CU_ASSERT_EQUAL_FATAL(ret_id, 3);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 2 + 65534 + 1 + 196608);\n\n /*After extending beyond 100MB subsequent extension doesn't double but adds 100MB*/\n ret_id = tsk_node_table_add_row(\n &tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, 104857600);\n CU_ASSERT_EQUAL_FATAL(ret_id, 4);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 105119745);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, 5);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 105119745 + 104857600);\n\n /*Extending by more bytes than possible results in overflow*/\n ret_id = tsk_node_table_add_row(\n &tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, TSK_MAX_SIZE);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 105119745 + 104857600);\n\n tsk_node_table_free(&tables.nodes);\n ret = tsk_node_table_init(&tables.nodes, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /*Setting a custom extension uses that*/\n ret = tsk_node_table_set_max_metadata_length_increment(&tables.nodes, 42);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, 3);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 43);\n\n /*Setting a custom extension that overflows errors*/\n ret = tsk_node_table_set_max_metadata_length_increment(&tables.nodes, TSK_MAX_SIZE);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, 41);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 43);\n\n tsk_table_collection_free(&tables);\n tsk_safe_free(data);\n}\n\nstatic void\ntest_link_ancestors_input_errors(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_edge_table_t result;\n tsk_id_t samples[] = { 0, 1 };\n tsk_id_t ancestors[] = { 4, 6 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Add an edge with some metadata */\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 7);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0, 1, 7, 6, \"metadata\", 8);\n CU_ASSERT_FATAL(ret_id > 0);\n\n ret = tsk_edge_table_init(&result, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_link_ancestors(\n &tables, NULL, 2, ancestors, 2, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_CANT_PROCESS_EDGES_WITH_METADATA);\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n tsk_edge_table_free(&result);\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_init(&result, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_link_ancestors(\n &tables, NULL, 2, ancestors, 2, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* Bad sample IDs */\n samples[0] = -1;\n ret = tsk_table_collection_link_ancestors(\n &tables, samples, 2, ancestors, 2, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n /* Bad ancestor IDs */\n samples[0] = 0;\n ancestors[0] = -1;\n ret = tsk_table_collection_link_ancestors(\n &tables, samples, 2, ancestors, 2, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n /* Duplicate sample IDs */\n ancestors[0] = 4;\n samples[0] = 1;\n ret = tsk_table_collection_link_ancestors(\n &tables, samples, 2, ancestors, 2, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n\n /* Duplicate sample IDs */\n ancestors[0] = 6;\n samples[0] = 0;\n ret = tsk_table_collection_link_ancestors(\n &tables, samples, 2, ancestors, 2, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n\n /* TODO more tests! */\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n tsk_edge_table_free(&result);\n}\n\nstatic void\ntest_link_ancestors_single_tree(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_edge_table_t result;\n tsk_id_t samples[] = { 0, 1 };\n tsk_id_t ancestors[] = { 4, 6 };\n size_t i;\n double res_left = 0;\n double res_right = 1;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_init(&result, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_link_ancestors(\n &tables, samples, 2, ancestors, 2, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // Check we get the right result.\n CU_ASSERT_EQUAL(result.num_rows, 3);\n tsk_id_t res_parent[] = { 4, 4, 6 };\n tsk_id_t res_child[] = { 0, 1, 4 };\n for (i = 0; i < result.num_rows; i++) {\n CU_ASSERT_EQUAL(res_parent[i], result.parent[i]);\n CU_ASSERT_EQUAL(res_child[i], result.child[i]);\n CU_ASSERT_EQUAL(res_left, result.left[i]);\n CU_ASSERT_EQUAL(res_right, result.right[i]);\n }\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n tsk_edge_table_free(&result);\n}\n\nstatic void\ntest_link_ancestors_no_edges(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_edge_table_t result;\n tsk_id_t samples[] = { 2 };\n tsk_id_t ancestors[] = { 4 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_init(&result, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_link_ancestors(\n &tables, samples, 1, ancestors, 1, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_table_collection_free(&tables);\n tsk_edge_table_free(&result);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_link_ancestors_samples_and_ancestors_overlap(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_edge_table_t result;\n tsk_id_t samples[] = { 0, 1, 2, 4 };\n tsk_id_t ancestors[] = { 2 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_init(&result, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_link_ancestors(\n &tables, samples, 4, ancestors, 1, 0, &result);\n\n // tsk_edge_table_print_state(&result, stdout);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n // Check we get the right result.\n CU_ASSERT_EQUAL(result.num_rows, 2);\n size_t i;\n tsk_id_t res_parent = 4;\n tsk_id_t res_child[] = { 0, 1 };\n double res_left = 0;\n double res_right = 1;\n for (i = 0; i < result.num_rows; i++) {\n CU_ASSERT_EQUAL(res_parent, result.parent[i]);\n CU_ASSERT_EQUAL(res_child[i], result.child[i]);\n CU_ASSERT_EQUAL(res_left, result.left[i]);\n CU_ASSERT_EQUAL(res_right, result.right[i]);\n }\n\n tsk_table_collection_free(&tables);\n tsk_edge_table_free(&result);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_link_ancestors_paper(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_edge_table_t result;\n tsk_id_t samples[] = { 0, 1, 2 };\n tsk_id_t ancestors[] = { 5, 6, 7 };\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_init(&result, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_link_ancestors(\n &tables, samples, 3, ancestors, 3, 0, &result);\n\n // tsk_edge_table_print_state(&result, stdout);\n\n // Check we get the right result.\n CU_ASSERT_EQUAL(result.num_rows, 6);\n size_t i;\n tsk_id_t res_parent[] = { 5, 5, 6, 6, 7, 7 };\n tsk_id_t res_child[] = { 1, 2, 0, 5, 0, 5 };\n double res_left[] = { 0, 2, 0, 0, 7, 7 };\n double res_right[] = { 10, 10, 7, 7, 10, 10 };\n for (i = 0; i < result.num_rows; i++) {\n CU_ASSERT_EQUAL(res_parent[i], result.parent[i]);\n CU_ASSERT_EQUAL(res_child[i], result.child[i]);\n CU_ASSERT_EQUAL(res_left[i], result.left[i]);\n CU_ASSERT_EQUAL(res_right[i], result.right[i]);\n }\n\n tsk_table_collection_free(&tables);\n tsk_edge_table_free(&result);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_link_ancestors_multiple_to_single_tree(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_edge_table_t result;\n tsk_id_t samples[] = { 1, 3 };\n tsk_id_t ancestors[] = { 5 };\n size_t i;\n tsk_id_t res_parent = 5;\n tsk_id_t res_child[] = { 1, 3 };\n double res_left = 0;\n double res_right = 10;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_init(&result, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_link_ancestors(\n &tables, samples, 2, ancestors, 1, 0, &result);\n\n CU_ASSERT_EQUAL(result.num_rows, 2);\n for (i = 0; i < result.num_rows; i++) {\n CU_ASSERT_EQUAL(res_parent, result.parent[i]);\n CU_ASSERT_EQUAL(res_child[i], result.child[i]);\n CU_ASSERT_EQUAL(res_left, result.left[i]);\n CU_ASSERT_EQUAL(res_right, result.right[i]);\n }\n\n tsk_table_collection_free(&tables);\n tsk_edge_table_free(&result);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\nverify_ibd_segment_list(tsk_identity_segment_list_t *list, tsk_size_t num_nodes)\n{\n tsk_identity_segment_t *seg;\n double total_span = 0;\n tsk_size_t num_segments = 0;\n /* double last_right = 0; */\n\n for (seg = list->head; seg != NULL; seg = seg->next) {\n CU_ASSERT_FATAL(seg->left < seg->right);\n CU_ASSERT_FATAL(seg->node >= 0);\n CU_ASSERT_FATAL(seg->node < (tsk_id_t) num_nodes);\n total_span += seg->right - seg->left;\n num_segments++;\n\n /* TODO the segments are not necessarily in order - issue #1682 */\n /* CU_ASSERT_FATAL(seg->left >= last_right); */\n /* last_right = seg->right; */\n }\n CU_ASSERT_EQUAL_FATAL(total_span, list->total_span);\n CU_ASSERT_EQUAL_FATAL(num_segments, list->num_segments);\n}\n\nstatic void\nverify_ibd_result(tsk_identity_segments_t *result)\n{\n int ret;\n tsk_size_t j;\n tsk_id_t a, b;\n int64_t index;\n tsk_size_t total_segments = 0;\n double total_span = 0;\n tsk_size_t num_pairs = tsk_identity_segments_get_num_pairs(result);\n tsk_id_t *pairs\n = tsk_malloc(2 * tsk_identity_segments_get_num_pairs(result) * sizeof(*pairs));\n tsk_id_t *pairs2\n = tsk_malloc(2 * tsk_identity_segments_get_num_pairs(result) * sizeof(*pairs));\n tsk_identity_segment_list_t **lists\n = tsk_malloc(tsk_identity_segments_get_num_pairs(result) * sizeof(*lists));\n tsk_avl_node_int_t **avl_nodes\n = tsk_malloc(result->pair_map.size * sizeof(*avl_nodes));\n\n CU_ASSERT_FATAL(pairs != NULL);\n CU_ASSERT_FATAL(pairs2 != NULL);\n CU_ASSERT_FATAL(avl_nodes != NULL);\n CU_ASSERT_FATAL(lists != NULL);\n CU_ASSERT_EQUAL_FATAL(num_pairs, result->pair_map.size);\n tsk_identity_segments_print_state(result, _devnull);\n\n ret = tsk_identity_segments_get_keys(result, pairs);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_avl_tree_int_ordered_nodes(&result->pair_map, avl_nodes);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = 0; j < num_pairs; j++) {\n a = pairs[2 * j];\n b = pairs[2 * j + 1];\n index = a * (int64_t) result->num_nodes + b;\n CU_ASSERT(a < b);\n CU_ASSERT_EQUAL(tsk_avl_tree_int_search(&result->pair_map, index), avl_nodes[j]);\n index = b * (int64_t) result->num_nodes + a;\n CU_ASSERT_EQUAL(tsk_avl_tree_int_search(&result->pair_map, index), NULL);\n }\n\n ret = tsk_identity_segments_get_items(result, pairs2, lists);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < num_pairs; j++) {\n CU_ASSERT_EQUAL_FATAL(pairs[2 * j], pairs2[2 * j]);\n CU_ASSERT_EQUAL_FATAL(pairs[2 * j + 1], pairs2[2 * j + 1]);\n verify_ibd_segment_list(lists[j], result->num_nodes);\n total_segments += lists[j]->num_segments;\n total_span += lists[j]->total_span;\n }\n CU_ASSERT_EQUAL_FATAL(result->num_segments, total_segments);\n CU_ASSERT_DOUBLE_EQUAL(result->total_span, total_span, 1e-6);\n\n free(pairs);\n free(pairs2);\n free(lists);\n free(avl_nodes);\n}\n\nstatic void\ntest_ibd_segments_debug(void)\n{\n tsk_treeseq_t ts;\n int ret;\n tsk_identity_segments_t result;\n tsk_size_t sizes[] = { 2, 2 };\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n\n tsk_set_debug_stream(_devnull);\n /* Run the DEBUG code */\n ret = tsk_table_collection_ibd_within(\n ts.tables, &result, NULL, 0, 0.0, DBL_MAX, TSK_DEBUG);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_identity_segments_free(&result);\n\n ret = tsk_table_collection_ibd_between(\n ts.tables, &result, 2, sizes, samples, 0.0, DBL_MAX, TSK_DEBUG);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_identity_segments_free(&result);\n\n ret = tsk_table_collection_ibd_within(\n ts.tables, &result, NULL, 0, 0.0, DBL_MAX, TSK_DEBUG | TSK_IBD_STORE_PAIRS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_identity_segments_free(&result);\n\n ret = tsk_table_collection_ibd_within(\n ts.tables, &result, NULL, 0, 0.0, DBL_MAX, TSK_DEBUG | TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_identity_segments_free(&result);\n\n tsk_set_debug_stream(stdout);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_ibd_segments_caterpillar_tree(void)\n{\n int ret;\n tsk_identity_segments_t result;\n tsk_treeseq_t *ts = caterpillar_tree(100, 1, 5);\n\n /* We're just testing out the memory expansion in ibd_finder */\n ret = tsk_table_collection_ibd_within(ts->tables, &result, NULL, 0, 0.0, DBL_MAX, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_identity_segments_free(&result);\n\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\ntest_ibd_segments_single_tree(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_id_t samples[] = { 0, 1 };\n tsk_size_t sizes[] = { 1, 1 };\n tsk_identity_segments_t result;\n tsk_identity_segment_list_t *list = NULL;\n tsk_identity_segment_t *seg = NULL;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Only get IBD segs for (0, 1) */\n ret = tsk_table_collection_ibd_within(\n &tables, &result, samples, 2, 0.0, DBL_MAX, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_identity_segments_get(&result, samples[0], samples[1], &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(list != NULL);\n seg = list->head;\n CU_ASSERT_EQUAL_FATAL(seg->next, NULL);\n CU_ASSERT_EQUAL_FATAL(seg->left, 0);\n CU_ASSERT_EQUAL_FATAL(seg->right, 1);\n CU_ASSERT_EQUAL_FATAL(seg->node, 4);\n\n /* Queries for other sample pairs fail */\n ret = tsk_identity_segments_get(&result, 0, 2, &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(list, NULL);\n ret = tsk_identity_segments_get(&result, 1, 3, &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(list, NULL);\n\n tsk_identity_segments_print_state(&result, _devnull);\n CU_ASSERT_EQUAL_FATAL(tsk_identity_segments_get_num_segments(&result), 1);\n CU_ASSERT_EQUAL_FATAL(tsk_identity_segments_get_total_span(&result), 1);\n verify_ibd_result(&result);\n tsk_identity_segments_free(&result);\n\n /* Get IBD segs among all pairs of samples */\n ret = tsk_table_collection_ibd_within(\n &tables, &result, NULL, 0, 0.0, DBL_MAX, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* We have 4 samples, so 4 choose 2 sample pairs */\n CU_ASSERT_EQUAL_FATAL(tsk_identity_segments_get_num_segments(&result), 6);\n CU_ASSERT_EQUAL_FATAL(tsk_identity_segments_get_total_span(&result), 6);\n\n ret = tsk_identity_segments_get(&result, 0, 1, &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n seg = list->head;\n CU_ASSERT_FATAL(seg != NULL);\n CU_ASSERT_EQUAL_FATAL(seg->next, NULL);\n CU_ASSERT_EQUAL_FATAL(seg->left, 0);\n CU_ASSERT_EQUAL_FATAL(seg->right, 1);\n CU_ASSERT_EQUAL_FATAL(seg->node, 4);\n\n ret = tsk_identity_segments_get(&result, 3, 0, &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n seg = list->head;\n CU_ASSERT_FATAL(seg != NULL);\n CU_ASSERT_EQUAL_FATAL(seg->next, NULL);\n CU_ASSERT_EQUAL_FATAL(seg->left, 0);\n CU_ASSERT_EQUAL_FATAL(seg->right, 1);\n CU_ASSERT_EQUAL_FATAL(seg->node, 6);\n\n verify_ibd_result(&result);\n tsk_identity_segments_free(&result);\n\n /* Get segs between {0} and {1} */\n ret = tsk_table_collection_ibd_between(\n ts.tables, &result, 2, sizes, samples, 0.0, DBL_MAX, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n verify_ibd_result(&result);\n CU_ASSERT_EQUAL_FATAL(tsk_identity_segments_get_num_segments(&result), 1);\n ret = tsk_identity_segments_get(&result, 0, 1, &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n seg = list->head;\n CU_ASSERT_FATAL(seg != NULL);\n CU_ASSERT_EQUAL_FATAL(seg->next, NULL);\n CU_ASSERT_EQUAL_FATAL(seg->left, 0);\n CU_ASSERT_EQUAL_FATAL(seg->right, 1);\n CU_ASSERT_EQUAL_FATAL(seg->node, 4);\n\n tsk_identity_segments_free(&result);\n\n /* within an empty list gives no segments */\n ret = tsk_table_collection_ibd_within(&tables, &result, samples, 0, 0.0, DBL_MAX, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tsk_identity_segments_get_num_segments(&result), 0);\n tsk_identity_segments_free(&result);\n\n /* Between an empty list gives no segments */\n ret = tsk_table_collection_ibd_between(\n ts.tables, &result, 0, sizes, samples, 0.0, DBL_MAX, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tsk_identity_segments_get_num_segments(&result), 0);\n tsk_identity_segments_free(&result);\n\n /* Between one empty list gives no segments*/\n sizes[0] = 0;\n ret = tsk_table_collection_ibd_between(\n ts.tables, &result, 2, sizes, samples, 0.0, DBL_MAX, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tsk_identity_segments_get_num_segments(&result), 0);\n tsk_identity_segments_free(&result);\n sizes[0] = 2;\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_ibd_segments_single_tree_options(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_identity_segments_t result;\n tsk_identity_segment_list_t *list = NULL;\n tsk_id_t pairs[12];\n tsk_identity_segment_list_t *lists[6];\n tsk_flags_t options[2];\n int k;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_ibd_within(&tables, &result, NULL, 0, 0.0, DBL_MAX, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* We have 4 samples, so 4 choose 2 sample pairs */\n CU_ASSERT_EQUAL_FATAL(tsk_identity_segments_get_num_segments(&result), 6);\n CU_ASSERT_EQUAL_FATAL(tsk_identity_segments_get_total_span(&result), 6);\n /* out-of-bounds is still detected */\n ret = tsk_identity_segments_get(&result, 0, 100, &list);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n /* By default all specific queries fail on the ibd_segments result */\n ret = tsk_identity_segments_get(&result, 0, 1, &list);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_IBD_PAIRS_NOT_STORED);\n ret = tsk_identity_segments_get_keys(&result, pairs);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_IBD_PAIRS_NOT_STORED);\n ret = tsk_identity_segments_get_items(&result, pairs, lists);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_IBD_PAIRS_NOT_STORED);\n tsk_identity_segments_free(&result);\n\n ret = tsk_table_collection_ibd_within(\n &tables, &result, NULL, 0, 0.0, DBL_MAX, TSK_IBD_STORE_PAIRS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* out-of-bounds is still detected */\n ret = tsk_identity_segments_get(&result, 0, 100, &list);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n /* Getters for the lists now work, but the lists themselves are NULL */\n ret = tsk_identity_segments_get(&result, 0, 1, &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(list->head, NULL);\n CU_ASSERT_EQUAL_FATAL(list->total_span, 1);\n CU_ASSERT_EQUAL_FATAL(list->num_segments, 1);\n ret = tsk_identity_segments_get_keys(&result, pairs);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(pairs[0], 0);\n CU_ASSERT_EQUAL_FATAL(pairs[1], 1);\n ret = tsk_identity_segments_get_items(&result, pairs, lists);\n CU_ASSERT_EQUAL_FATAL(pairs[0], 0);\n CU_ASSERT_EQUAL_FATAL(pairs[1], 1);\n CU_ASSERT_EQUAL_FATAL(lists[0]->head, NULL);\n CU_ASSERT_EQUAL_FATAL(lists[0]->total_span, 1);\n CU_ASSERT_EQUAL_FATAL(lists[0]->num_segments, 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_identity_segments_free(&result);\n\n /* store_segments implies store_pairs */\n options[0] = TSK_IBD_STORE_SEGMENTS;\n options[1] = TSK_IBD_STORE_PAIRS | TSK_IBD_STORE_SEGMENTS;\n for (k = 0; k < 2; k++) {\n\n ret = tsk_table_collection_ibd_within(\n &tables, &result, NULL, 0, 0.0, DBL_MAX, options[k]);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* out-of-bounds is still detected */\n ret = tsk_identity_segments_get(&result, 0, 100, &list);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_identity_segments_get(&result, 0, 1, &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(list->head != NULL);\n CU_ASSERT_EQUAL_FATAL(list->head->left, 0);\n CU_ASSERT_EQUAL_FATAL(list->head->right, 1);\n CU_ASSERT_EQUAL_FATAL(list->head->next, NULL);\n CU_ASSERT_EQUAL_FATAL(list->total_span, 1);\n CU_ASSERT_EQUAL_FATAL(list->num_segments, 1);\n ret = tsk_identity_segments_get_keys(&result, pairs);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(pairs[0], 0);\n CU_ASSERT_EQUAL_FATAL(pairs[1], 1);\n ret = tsk_identity_segments_get_items(&result, pairs, lists);\n CU_ASSERT_EQUAL_FATAL(pairs[0], 0);\n CU_ASSERT_EQUAL_FATAL(pairs[1], 1);\n CU_ASSERT_FATAL(lists[0]->head != NULL);\n CU_ASSERT_EQUAL_FATAL(lists[0]->head->left, 0);\n CU_ASSERT_EQUAL_FATAL(lists[0]->head->right, 1);\n CU_ASSERT_EQUAL_FATAL(lists[0]->head->next, NULL);\n CU_ASSERT_EQUAL_FATAL(lists[0]->total_span, 1);\n CU_ASSERT_EQUAL_FATAL(lists[0]->num_segments, 1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_identity_segments_free(&result);\n }\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_ibd_segments_single_tree_between(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t sizes[] = { 2, 2 };\n tsk_identity_segments_t result;\n tsk_identity_segment_list_t *list = NULL;\n tsk_identity_segment_t *seg = NULL;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Get segs between {0, 1} and {2, 3} */\n ret = tsk_table_collection_ibd_between(\n ts.tables, &result, 2, sizes, samples, 0.0, DBL_MAX, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n verify_ibd_result(&result);\n CU_ASSERT_EQUAL_FATAL(tsk_identity_segments_get_num_segments(&result), 4);\n\n ret = tsk_identity_segments_get(&result, 0, 2, &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n seg = list->head;\n CU_ASSERT_FATAL(seg != NULL);\n CU_ASSERT_EQUAL_FATAL(seg->next, NULL);\n CU_ASSERT_EQUAL_FATAL(seg->left, 0);\n CU_ASSERT_EQUAL_FATAL(seg->right, 1);\n CU_ASSERT_EQUAL_FATAL(seg->node, 6);\n\n ret = tsk_identity_segments_get(&result, 0, 3, &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n seg = list->head;\n CU_ASSERT_FATAL(seg != NULL);\n CU_ASSERT_EQUAL_FATAL(seg->next, NULL);\n CU_ASSERT_EQUAL_FATAL(seg->left, 0);\n CU_ASSERT_EQUAL_FATAL(seg->right, 1);\n CU_ASSERT_EQUAL_FATAL(seg->node, 6);\n\n ret = tsk_identity_segments_get(&result, 1, 2, &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n seg = list->head;\n CU_ASSERT_FATAL(seg != NULL);\n CU_ASSERT_EQUAL_FATAL(seg->next, NULL);\n CU_ASSERT_EQUAL_FATAL(seg->left, 0);\n CU_ASSERT_EQUAL_FATAL(seg->right, 1);\n CU_ASSERT_EQUAL_FATAL(seg->node, 6);\n\n ret = tsk_identity_segments_get(&result, 1, 3, &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n seg = list->head;\n CU_ASSERT_FATAL(seg != NULL);\n CU_ASSERT_EQUAL_FATAL(seg->next, NULL);\n CU_ASSERT_EQUAL_FATAL(seg->left, 0);\n CU_ASSERT_EQUAL_FATAL(seg->right, 1);\n CU_ASSERT_EQUAL_FATAL(seg->node, 6);\n\n tsk_identity_segments_free(&result);\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_ibd_segments_multiple_trees(void)\n{\n int ret;\n tsk_size_t j, k;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_id_t samples[] = { 0, 1, 2 };\n tsk_id_t pairs[][2] = { { 0, 1 }, { 0, 2 } };\n tsk_size_t num_samples = 3;\n tsk_size_t num_pairs = 2;\n tsk_identity_segments_t result;\n double true_left[2][2] = { { 0.0, 0.75 }, { 0.75, 0.0 } };\n double true_right[2][2] = { { 0.75, 1.0 }, { 1.0, 0.75 } };\n double true_node[2][2] = { { 4, 5 }, { 5, 6 } };\n tsk_identity_segment_list_t *list;\n tsk_identity_segment_t *seg;\n\n tsk_treeseq_from_text(&ts, 2, multiple_tree_ex_nodes, multiple_tree_ex_edges, NULL,\n NULL, NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_ibd_within(\n &tables, &result, samples, num_samples, 0.0, DBL_MAX, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < num_pairs; j++) {\n ret = tsk_identity_segments_get(&result, pairs[j][0], pairs[j][1], &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(list->num_segments, 2);\n k = 0;\n for (seg = list->head; seg != NULL; seg = seg->next) {\n CU_ASSERT_EQUAL_FATAL(seg->left, true_left[j][k]);\n CU_ASSERT_EQUAL_FATAL(seg->right, true_right[j][k]);\n CU_ASSERT_EQUAL_FATAL(seg->node, true_node[j][k]);\n k++;\n }\n CU_ASSERT_EQUAL_FATAL(list->num_segments, k);\n }\n\n verify_ibd_result(&result);\n tsk_identity_segments_free(&result);\n\n ret = tsk_table_collection_ibd_within(\n &tables, &result, NULL, 0, 0.0, DBL_MAX, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n verify_ibd_result(&result);\n tsk_identity_segments_free(&result);\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_ibd_segments_empty_result(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_id_t samples[] = { 0, 1 };\n tsk_identity_segments_t result;\n tsk_identity_segment_list_t *list;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_ibd_within(\n &tables, &result, samples, 1, 0.0, 0.5, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_identity_segments_get(&result, samples[0], samples[1], &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(list == NULL);\n\n verify_ibd_result(&result);\n tsk_identity_segments_free(&result);\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_ibd_segments_min_span_max_time(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_identity_segments_t result;\n tsk_identity_segment_list_t *list;\n tsk_identity_segment_t *seg;\n\n tsk_treeseq_from_text(&ts, 2, multiple_tree_ex_nodes, multiple_tree_ex_edges, NULL,\n NULL, NULL, NULL, NULL, 0);\n\n ret = tsk_table_collection_ibd_within(\n ts.tables, &result, NULL, 0, 0.5, 3.0, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_identity_segments_get(&result, 0, 1, &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(list->num_segments, 1);\n seg = list->head;\n CU_ASSERT_EQUAL_FATAL(seg->left, 0.0);\n CU_ASSERT_EQUAL_FATAL(seg->right, 0.75);\n CU_ASSERT_EQUAL_FATAL(seg->node, 4);\n\n ret = tsk_identity_segments_get(&result, 1, 2, &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(list, NULL);\n\n ret = tsk_identity_segments_get(&result, 0, 2, &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(list, NULL);\n\n verify_ibd_result(&result);\n tsk_identity_segments_free(&result);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_ibd_segments_errors(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_id_t samples[] = { 0, 1, 2 };\n tsk_id_t duplicate_samples[] = { 0, 1, 0 };\n tsk_id_t samples2[] = { -1, 1 };\n tsk_size_t sample_set_sizes[] = { 3 };\n tsk_identity_segments_t result;\n tsk_identity_segment_list_t *list;\n\n tsk_treeseq_from_text(&ts, 2, multiple_tree_ex_nodes, multiple_tree_ex_edges, NULL,\n NULL, NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // Invalid sample IDs\n ret = tsk_table_collection_ibd_within(\n &tables, &result, samples2, 1, 0.0, DBL_MAX, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tsk_identity_segments_free(&result);\n\n ret = tsk_table_collection_ibd_between(&tables, &result, 1, sample_set_sizes,\n samples2, 0.0, DBL_MAX, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tsk_identity_segments_free(&result);\n\n // Bad length or time\n ret = tsk_table_collection_ibd_within(&tables, &result, samples, 2, 0.0, -1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n tsk_identity_segments_free(&result);\n ret = tsk_table_collection_ibd_within(&tables, &result, samples, 2, -1, 0.0, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n tsk_identity_segments_free(&result);\n\n ret = tsk_table_collection_ibd_between(&tables, &result, 1, sample_set_sizes,\n samples, -1, DBL_MAX, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n tsk_identity_segments_free(&result);\n ret = tsk_table_collection_ibd_between(\n &tables, &result, 1, sample_set_sizes, samples, 0, -1, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n tsk_identity_segments_free(&result);\n\n // Duplicate samples\n ret = tsk_table_collection_ibd_within(\n &tables, &result, duplicate_samples, 3, 0.0, DBL_MAX, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n tsk_identity_segments_free(&result);\n\n ret = tsk_table_collection_ibd_between(&tables, &result, 1, sample_set_sizes,\n duplicate_samples, 0.0, DBL_MAX, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n tsk_identity_segments_free(&result);\n\n // Check for bad inputs to result\n ret = tsk_table_collection_ibd_within(\n &tables, &result, NULL, 0, 0.0, DBL_MAX, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_identity_segments_get(&result, 0, -1, &list);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_identity_segments_get(&result, -1, 0, &list);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_identity_segments_get(&result, 0, 100, &list);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_identity_segments_get(&result, 100, 0, &list);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n ret = tsk_identity_segments_get(&result, 0, 5, &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(list, NULL);\n /* TODO add more checks here */\n ret = tsk_identity_segments_get(&result, 0, 0, &list);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SAME_NODES_IN_PAIR);\n\n tsk_identity_segments_free(&result);\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_ibd_segments_samples_are_descendants(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_id_t samples[] = { 0, 1, 2, 3, 4, 5 };\n tsk_size_t num_samples = 6;\n tsk_identity_segments_t result;\n tsk_id_t pairs[][2] = { { 0, 2 }, { 0, 4 }, { 2, 4 }, { 1, 3 }, { 1, 5 }, { 3, 5 } };\n tsk_size_t num_pairs = 6;\n tsk_id_t true_node[] = { 2, 4, 4, 3, 5, 5 };\n tsk_size_t j;\n tsk_identity_segment_list_t *list;\n tsk_identity_segment_t *seg;\n\n tsk_treeseq_from_text(&ts, 1, multi_root_tree_ex_nodes, multi_root_tree_ex_edges,\n NULL, NULL, NULL, NULL, NULL, 0);\n\n ret = tsk_table_collection_ibd_within(\n ts.tables, &result, samples, num_samples, 0.0, DBL_MAX, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = 0; j < num_pairs; j++) {\n tsk_identity_segments_get(&result, pairs[j][0], pairs[j][1], &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(list != NULL);\n CU_ASSERT_EQUAL_FATAL(list->num_segments, 1);\n seg = list->head;\n\n CU_ASSERT_EQUAL_FATAL(seg->left, 0);\n CU_ASSERT_EQUAL_FATAL(seg->right, 1);\n CU_ASSERT_EQUAL_FATAL(seg->node, true_node[j]);\n }\n\n verify_ibd_result(&result);\n tsk_identity_segments_free(&result);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_ibd_segments_multiple_ibd_paths(void)\n{\n int ret;\n tsk_size_t j, k;\n tsk_treeseq_t ts;\n tsk_id_t pairs[][2] = { { 0, 1 }, { 0, 2 }, { 1, 2 } };\n tsk_size_t num_pairs = 3;\n tsk_identity_segments_t result;\n double true_left[3][2] = { { 0.2, 0.0 }, { 0.2, 0.0 }, { 0.0, 0.2 } };\n double true_right[3][2] = { { 1.0, 0.2 }, { 1.0, 0.2 }, { 0.2, 1.0 } };\n double true_node[3][2] = { { 4, 5 }, { 3, 5 }, { 4, 4 } };\n tsk_identity_segment_list_t *list;\n tsk_identity_segment_t *seg;\n\n tsk_treeseq_from_text(&ts, 2, multi_path_tree_ex_nodes, multi_path_tree_ex_edges,\n NULL, NULL, NULL, NULL, NULL, 0);\n\n ret = tsk_table_collection_ibd_within(\n ts.tables, &result, NULL, 0, 0.0, DBL_MAX, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < num_pairs; j++) {\n tsk_identity_segments_get(&result, pairs[j][0], pairs[j][1], &list);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n k = 0;\n for (seg = list->head; seg != NULL; seg = seg->next) {\n CU_ASSERT_EQUAL_FATAL(seg->left, true_left[j][k]);\n CU_ASSERT_EQUAL_FATAL(seg->right, true_right[j][k]);\n CU_ASSERT_EQUAL_FATAL(seg->node, true_node[j][k]);\n k++;\n }\n CU_ASSERT_EQUAL_FATAL(k, 2);\n }\n\n verify_ibd_result(&result);\n tsk_identity_segments_free(&result);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_ibd_segments_odd_topologies(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_id_t samples[] = { 0, 1 };\n tsk_id_t samples1[] = { 0, 2 };\n tsk_identity_segments_t result;\n\n tsk_treeseq_from_text(\n &ts, 1, odd_tree1_ex_nodes, odd_tree1_ex_edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // Multiple roots.\n ret = tsk_table_collection_ibd_within(\n &tables, &result, samples, 1, 0, 0, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n verify_ibd_result(&result);\n tsk_identity_segments_free(&result);\n\n // Parent is a sample.\n ret = tsk_table_collection_ibd_within(\n &tables, &result, samples1, 1, 0, 0, TSK_IBD_STORE_SEGMENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n verify_ibd_result(&result);\n tsk_identity_segments_free(&result);\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplify_tables_drops_indexes(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_id_t samples[] = { 0, 1 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_TRUE(tsk_table_collection_has_index(&tables, 0))\n ret = tsk_table_collection_simplify(&tables, samples, 2, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_has_index(&tables, 0))\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplify_empty_tables(void)\n{\n int ret;\n tsk_table_collection_t tables;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n ret = tsk_table_collection_simplify(&tables, NULL, 0, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 0);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplify_metadata(void)\n{\n int ret;\n tsk_table_collection_t tables;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 10;\n tsk_edge_table_add_row(&tables.edges, 0, 0, 1, 1, \"metadata\", 8);\n ret = tsk_table_collection_simplify(&tables, NULL, 0, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_CANT_PROCESS_EDGES_WITH_METADATA);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_edge_update_invalidates_index(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n\n /* Any operations on the edge table should now invalidate the index */\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_has_index(&tables, 0))\n ret = tsk_edge_table_clear(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_has_index(&tables, 0));\n /* Even though the actual indexes still exist */\n CU_ASSERT_FALSE(tables.indexes.edge_insertion_order == NULL);\n CU_ASSERT_FALSE(tables.indexes.edge_removal_order == NULL);\n CU_ASSERT_EQUAL_FATAL(tables.indexes.num_edges, tsk_treeseq_get_num_edges(&ts));\n\n ret = tsk_treeseq_copy_tables(&ts, &tables, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_has_index(&tables, 0))\n ret_id = tsk_edge_table_add_row(&tables.edges, 0, 1, 0, 1, NULL, 0);\n CU_ASSERT_TRUE(ret_id > 0);\n CU_ASSERT_FALSE(tsk_table_collection_has_index(&tables, 0));\n /* Even though the actual indexes still exist */\n CU_ASSERT_FALSE(tables.indexes.edge_insertion_order == NULL);\n CU_ASSERT_FALSE(tables.indexes.edge_removal_order == NULL);\n CU_ASSERT_EQUAL_FATAL(tables.indexes.num_edges, tsk_treeseq_get_num_edges(&ts));\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_copy_table_collection(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables, tables_copy;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Add some migrations, population and provenance */\n ret_id = tsk_migration_table_add_row(&tables.migrations, 0, 1, 2, 3, 4, 5, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_migration_table_add_row(&tables.migrations, 1, 2, 3, 4, 5, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_population_table_add_row(&tables.populations, \"metadata\", 8);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_population_table_add_row(&tables.populations, \"other\", 5);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_provenance_table_add_row(&tables.provenances, \"time\", 4, \"record\", 6);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_provenance_table_add_row(&tables.provenances, \"time \", 5, \"record \", 7);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n\n tsk_table_collection_copy(&tables, &tables_copy, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tables, &tables_copy, 0));\n\n tsk_table_collection_free(&tables);\n tsk_table_collection_free(&tables_copy);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_sort_tables_offsets(void)\n{\n int ret;\n tsk_treeseq_t *ts;\n tsk_table_collection_t tables, copy;\n tsk_bookmark_t bookmark;\n\n ts = caterpillar_tree(10, 5, 5);\n ret = tsk_treeseq_copy_tables(ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_sort(&tables, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Check that setting edge offset = len(edges) does nothing */\n reverse_edges(&tables);\n ret = tsk_table_collection_copy(&tables, ©, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_memset(&bookmark, 0, sizeof(bookmark));\n bookmark.edges = tables.edges.num_rows;\n ret = tsk_table_collection_sort(&tables, &bookmark, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tsk_table_collection_equals(&tables, ©, 0));\n\n ret = tsk_table_collection_sort(&tables, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Check that setting migration offset = len(migrations) does nothing */\n reverse_migrations(&tables);\n ret = tsk_table_collection_copy(&tables, ©, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_memset(&bookmark, 0, sizeof(bookmark));\n bookmark.migrations = tables.migrations.num_rows;\n ret = tsk_table_collection_sort(&tables, &bookmark, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tsk_table_collection_equals(&tables, ©, 0));\n\n ret = tsk_table_collection_sort(&tables, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tables.sites.num_rows > 2);\n CU_ASSERT_FATAL(tables.mutations.num_rows > 2);\n\n /* Check that setting mutation and site offset = to the len\n * of the tables leaves them untouched. */\n reverse_mutations(&tables);\n /* Swap the positions of the first two sites, as a quick way\n * to disorder the site table */\n tables.sites.position[0] = tables.sites.position[1];\n tables.sites.position[1] = 0;\n ret = tsk_table_collection_copy(&tables, ©, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_memset(&bookmark, 0, sizeof(bookmark));\n bookmark.sites = tables.sites.num_rows;\n bookmark.mutations = tables.mutations.num_rows;\n ret = tsk_table_collection_sort(&tables, &bookmark, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tsk_table_collection_equals(&tables, ©, 0));\n\n /* Anything other than len(table) leads to an error for sites\n * and mutations, and we can't specify one without the other. */\n tsk_memset(&bookmark, 0, sizeof(bookmark));\n bookmark.sites = tables.sites.num_rows;\n ret = tsk_table_collection_sort(&tables, &bookmark, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SORT_OFFSET_NOT_SUPPORTED);\n\n tsk_memset(&bookmark, 0, sizeof(bookmark));\n bookmark.mutations = tables.mutations.num_rows;\n ret = tsk_table_collection_sort(&tables, &bookmark, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SORT_OFFSET_NOT_SUPPORTED);\n\n tsk_memset(&bookmark, 0, sizeof(bookmark));\n bookmark.sites = tables.sites.num_rows - 1;\n bookmark.mutations = tables.mutations.num_rows - 1;\n ret = tsk_table_collection_sort(&tables, &bookmark, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SORT_OFFSET_NOT_SUPPORTED);\n\n /* Individuals must either all be sorted or all skipped */\n ret = tsk_table_collection_sort(&tables, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Add a parent relation that unsorts the table */\n tables.individuals.parents[0] = 5;\n ret = tsk_table_collection_copy(&tables, ©, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_memset(&bookmark, 0, sizeof(bookmark));\n bookmark.individuals = tables.individuals.num_rows;\n ret = tsk_table_collection_sort(&tables, &bookmark, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tables, ©, 0));\n\n /* Check that sorting would have had no effect as individuals not in default sort*/\n ret = tsk_table_collection_sort(&tables, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&tables, ©, 0));\n\n /* Individual bookmark ignored */\n tsk_memset(&bookmark, 0, sizeof(bookmark));\n bookmark.individuals = tables.individuals.num_rows - 1;\n ret = tsk_table_collection_sort(&tables, &bookmark, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_table_collection_free(&tables);\n tsk_table_collection_free(©);\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\ntest_sort_tables_drops_indexes_with_options(tsk_flags_t tc_options)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, tc_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_TRUE(tsk_table_collection_has_index(&tables, 0))\n ret = tsk_table_collection_sort(&tables, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_has_index(&tables, 0))\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_sort_tables_drops_indexes(void)\n{\n test_sort_tables_drops_indexes_with_options(0);\n test_sort_tables_drops_indexes_with_options(TSK_TC_NO_EDGE_METADATA);\n}\n\nstatic void\ntest_sort_tables_edge_metadata(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t t1, t2;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n insert_edge_metadata(&t1);\n ret = tsk_table_collection_copy(&t1, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n reverse_edges(&t1);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&t1, &t2, 0));\n ret = tsk_table_collection_sort(&t1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n\n tsk_table_collection_free(&t1);\n tsk_table_collection_free(&t2);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_sort_tables_no_edge_metadata(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t t1, t2;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &t1, TSK_TC_NO_EDGE_METADATA);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(t1.edges.options & TSK_TABLE_NO_METADATA);\n ret = tsk_table_collection_copy(&t1, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(t2.edges.options & TSK_TABLE_NO_METADATA);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n reverse_edges(&t1);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&t1, &t2, 0));\n ret = tsk_table_collection_sort(&t1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n tsk_table_collection_free(&t2);\n\n ret = tsk_table_collection_copy(&t1, &t2, TSK_TC_NO_EDGE_METADATA);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(t1.edges.options & TSK_TABLE_NO_METADATA);\n CU_ASSERT_TRUE(t2.edges.options & TSK_TABLE_NO_METADATA);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n reverse_edges(&t1);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&t1, &t2, 0));\n ret = tsk_table_collection_sort(&t1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n tsk_table_collection_free(&t2);\n\n tsk_table_collection_free(&t1);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_sort_tables_errors(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_bookmark_t pos;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_memset(&pos, 0, sizeof(pos));\n /* Everything 0 should be fine */\n ret = tsk_table_collection_sort(&tables, &pos, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Everything is sorted already */\n pos.edges = tables.edges.num_rows;\n ret = tsk_table_collection_sort(&tables, &pos, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n pos.edges = (tsk_size_t) -1;\n ret = tsk_table_collection_sort(&tables, &pos, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n\n pos.edges = tables.edges.num_rows + 1;\n ret = tsk_table_collection_sort(&tables, &pos, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n\n tsk_memset(&pos, 0, sizeof(pos));\n pos.migrations = (tsk_size_t) -1;\n ret = tsk_table_collection_sort(&tables, &pos, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATION_OUT_OF_BOUNDS);\n\n pos.migrations = tables.migrations.num_rows + 1;\n ret = tsk_table_collection_sort(&tables, &pos, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATION_OUT_OF_BOUNDS);\n\n /* Node, population and provenance positions are ignored */\n tsk_memset(&pos, 0, sizeof(pos));\n pos.nodes = 1;\n ret = tsk_table_collection_sort(&tables, &pos, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_memset(&pos, 0, sizeof(pos));\n pos.populations = 1;\n ret = tsk_table_collection_sort(&tables, &pos, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_memset(&pos, 0, sizeof(pos));\n pos.provenances = 1;\n ret = tsk_table_collection_sort(&tables, &pos, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Specifying only one of sites or mutations is an error */\n tsk_memset(&pos, 0, sizeof(pos));\n pos.sites = 1;\n ret = tsk_table_collection_sort(&tables, &pos, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SORT_OFFSET_NOT_SUPPORTED);\n\n tsk_memset(&pos, 0, sizeof(pos));\n pos.mutations = 1;\n ret = tsk_table_collection_sort(&tables, &pos, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SORT_OFFSET_NOT_SUPPORTED);\n\n /* Test TSK_ERR_MUTATION_PARENT_INCONSISTENT */\n ret = tsk_table_collection_clear(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1.0;\n\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.0, \"x\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret_id\n = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 2, 0.0, \"a\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 3, 0.0, \"b\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 1, 0.0, \"c\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 2, 0.0, \"d\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_table_collection_sort(&tables, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_PARENT_INCONSISTENT);\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_sort_tables_mutation_times(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables, t1, t2;\n const char *sites = \"0 0\\n\"\n \"0.1 0\\n\"\n \"0.2 0\\n\"\n \"0.3 0\\n\";\n const char *mutations = \"0 0 1 -1 3\\n\"\n \"1 1 1 -1 3\\n\"\n \"2 4 1 -1 8\\n\"\n \"2 1 0 -1 4\\n\"\n \"2 2 1 -1 3\\n\"\n \"2 1 1 -1 2\\n\"\n \"3 6 1 -1 10\\n\";\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1;\n parse_nodes(single_tree_ex_nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 7);\n tables.nodes.time[4] = 6;\n tables.nodes.time[5] = 8;\n tables.nodes.time[6] = 10;\n parse_edges(single_tree_ex_edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 6);\n parse_sites(sites, &tables.sites);\n parse_mutations(mutations, &tables.mutations);\n CU_ASSERT_EQUAL_FATAL(tables.sites.num_rows, 4);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.num_rows, 7);\n tables.sequence_length = 1.0;\n\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Check to make sure we have legal mutations */\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_COMPUTE_MUTATION_PARENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_copy_tables(&ts, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_copy(&t1, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n reverse_mutations(&t1);\n CU_ASSERT_FALSE(tsk_table_collection_equals(&t1, &t2, 0));\n ret = tsk_table_collection_sort(&t1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n tsk_table_collection_free(&t2);\n\n tsk_table_collection_free(&t1);\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_sort_tables_mutations(void)\n{\n int ret;\n tsk_table_collection_t tables;\n\n /* Sorting hierarchy:\n * 1. site\n * 2. time (when known)\n * 3. node_time\n * 4. num_descendants: parent mutations first\n * 5. node_id\n * 6. mutation_id\n */\n\n const char *sites = \"0.0 A\\n\"\n \"0.5 T\\n\"\n \"0.75 G\\n\";\n\n const char *mutations_unsorted =\n /* Test site criterion (primary) - site 1 should come after site 0 */\n \"1 0 X -1 0.0\\n\" /* mut 0: site 1, will be sorted after site 0 mutations */\n \"0 0 Y -1 0.0\\n\" /* mut 1: site 0, will be sorted before site 1 mutations */\n\n /* Test time criterion - within same site, earlier time first */\n \"0 4 B -1 2.0\\n\" /* mut 2: site 0, node 4 (time 1.0), time 2.0 (later time)\n */\n \"0 5 A -1 2.5\\n\" /* mut 3: site 0, node 5 (time 2.0), time 2.5 (earlier\n relative) */\n\n /* Test unknown vs known times - unknown times at site 2, fall back to node_time\n sorting */\n \"2 4 U2 -1\\n\" /* mut 4: site 2, node 4 (time 1.0), unknown time - falls back\n to node_time */\n \"2 4 U3 -1\\n\" /* mut 5: site 2, node 4 (time 1.0), unknown time - should use\n mutation_id as tiebreaker */\n \"2 5 U1 -1\\n\" /* mut 6: site 2, node 5 (time 2.0), unknown time - falls back\n to node_time */\n\n /* Test node_time criterion - same site, same mut time, different node times */\n \"0 4 D -1 1.5\\n\" /* mut 7: site 0, node 4 (time 1.0), mut time 1.5 */\n \"0 5 C -1 2.5\\n\" /* mut 8: site 0, node 5 (time 2.0), mut time 2.5 - same\n mut time */\n\n /* Test num_descendants criterion with mutation parent-child relationships */\n \"0 2 P -1 0.0\\n\" /* mut 9: site 0, node 2, parent mutation (0 descendants\n initially) */\n \"0 1 C1 9 0.0\\n\" /* mut 10: site 0, node 1, child of mut 9 (parent now has\n 1+ descendants) */\n \"0 1 C2 9 0.0\\n\" /* mut 11: site 0, node 1, another child of mut 9 (parent\n now has 2+ descendants) */\n \"0 3 Q -1 0.0\\n\" /* mut 12: site 0, node 3, no children (0 descendants) */\n \"0 0 C3 10 0.0\\n\" /* mut 13: site 0, node 0, child of mut 10 (making mut 9 a\n grandparent) */\n\n /* Test node and mutation_id criteria for final tiebreaking */\n \"0 0 Z1 -1 0.0\\n\" /* mut 14: site 0, node 0, no parent, will test node+id\n ordering */\n \"0 0 Z2 -1 0.0\\n\"; /* mut 15: site 0, node 0, no parent, later in input =\n higher ID */\n\n const char *mutations_sorted =\n /* Site 0 mutations - known times first, sorted by time */\n \"0 5 A -1 2.5\\n\"\n \"0 5 C -1 2.5\\n\"\n \"0 4 B -1 2.0\\n\"\n \"0 4 D -1 1.5\\n\"\n \"0 2 P -1 0.0\\n\"\n \"0 1 C1 4 0.0\\n\"\n \"0 0 Y -1 0.0\\n\"\n \"0 0 C3 5 0.0\\n\"\n \"0 0 Z1 -1 0.0\\n\"\n \"0 0 Z2 -1 0.0\\n\"\n \"0 1 C2 4 0.0\\n\"\n \"0 3 Q -1 0.0\\n\"\n\n /* Site 1 mutations */\n \"1 0 X -1 0.0\\n\"\n\n /* Site 2 mutations - unknown times, sorted by node_time then other criteria */\n \"2 5 U1 -1\\n\"\n \"2 4 U2 -1\\n\"\n \"2 4 U3 -1\\n\";\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1.0;\n parse_nodes(single_tree_ex_nodes, &tables.nodes);\n parse_edges(single_tree_ex_edges, &tables.edges);\n\n parse_sites(sites, &tables.sites);\n CU_ASSERT_EQUAL_FATAL(tables.sites.num_rows, 3);\n\n parse_mutations(mutations_unsorted, &tables.mutations);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.num_rows, 16);\n\n ret = tsk_table_collection_sort(&tables, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_table_collection_t expected;\n ret = tsk_table_collection_init(&expected, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n expected.sequence_length = 1.0;\n parse_nodes(single_tree_ex_nodes, &expected.nodes);\n parse_edges(single_tree_ex_edges, &expected.edges);\n parse_sites(sites, &expected.sites);\n parse_mutations(mutations_sorted, &expected.mutations);\n\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&tables.mutations, &expected.mutations, 0));\n\n tsk_table_collection_free(&expected);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_sort_tables_canonical_errors(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n tsk_id_t null_p[] = { -1 };\n tsk_id_t zero_p[] = { 0 };\n tsk_id_t one_p[] = { 1 };\n\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.0, \"x\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 2, 0.0, \"a\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 3, 0.0, \"b\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 1, 0.0, \"c\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 2, 0.0, \"d\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_table_collection_canonicalise(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_PARENT_INCONSISTENT);\n\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_FATAL(ret == 0);\n ret_id\n = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 2, 0.0, \"a\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 3, 0.0, \"b\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 1, 0.0, \"c\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_mutation_table_add_row(&tables.mutations, 0, 0, -1, 0.0, \"d\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_table_collection_canonicalise(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0.0, TSK_NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0.0, TSK_NULL, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, one_p, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, zero_p, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_table_collection_canonicalise(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_PARENT_CYCLE);\n\n ret = tsk_individual_table_clear(&tables.individuals);\n CU_ASSERT_FATAL(ret == 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, zero_p, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, zero_p, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_table_collection_canonicalise(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_SELF_PARENT);\n\n ret = tsk_individual_table_clear(&tables.individuals);\n CU_ASSERT_FATAL(ret == 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, null_p, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, zero_p, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_table_collection_canonicalise(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_sort_tables_canonical(void)\n{\n int ret;\n tsk_table_collection_t t1, t2;\n // this is single_tree_ex with individuals and populations\n const char *nodes = \"1 0 -1 1\\n\"\n \"1 0 2 3\\n\"\n \"1 0 0 -1\\n\"\n \"1 0 -1 3\\n\"\n \"0 1 2 -1\\n\"\n \"0 2 -1 2\\n\"\n \"0 3 -1 -1\\n\";\n const char *individuals = \"0 0.0 1\\n\"\n \"0 1.0 -1\\n\"\n \"0 2.0 1,3\\n\"\n \"0 3.0 -1,1\\n\";\n const char *sites = \"0 0\\n\"\n \"0.2 0\\n\"\n \"0.1 0\\n\";\n const char *mutations = \"0 0 2 3 0.5\\n\"\n \"2 1 1 -1 0.5\\n\"\n \"1 4 3 -1 3\\n\"\n \"0 4 1 -1 2.5\\n\"\n \"2 2 1 -1 2\\n\"\n \"1 1 5 7 0.5\\n\"\n \"1 2 1 -1 2\\n\"\n \"1 1 4 2 0.5\\n\"\n \"1 1 6 7 0.5\\n\";\n const char *nodes_sorted = \"1 0 -1 0\\n\"\n \"1 0 0 1\\n\"\n \"1 0 1 -1\\n\"\n \"1 0 -1 1\\n\"\n \"0 1 0 -1\\n\"\n \"0 2 -1 2\\n\"\n \"0 3 -1 -1\\n\";\n const char *individuals_sorted = \"0 1.0 -1\\n\"\n \"0 3.0 -1,0\\n\"\n \"0 2.0 0,1\\n\";\n const char *sites_sorted = \"0 0\\n\"\n \"0.1 0\\n\"\n \"0.2 0\\n\";\n const char *mutations_sorted = \"0 4 1 -1 2.5\\n\"\n \"0 0 2 0 0.5\\n\"\n \"1 2 1 -1 2\\n\"\n \"1 1 1 -1 0.5\\n\"\n \"2 4 3 -1 3\\n\"\n \"2 2 1 -1 2\\n\"\n \"2 1 4 4 0.5\\n\"\n \"2 1 5 6 0.5\\n\"\n \"2 1 6 6 0.5\\n\";\n const char *individuals_sorted_kept = \"0 1.0 -1\\n\"\n \"0 3.0 -1,0\\n\"\n \"0 2.0 0,1\\n\"\n \"0 0.0 0\\n\";\n\n ret = tsk_table_collection_init(&t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n t1.sequence_length = 1.0;\n ret = tsk_table_collection_init(&t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n t2.sequence_length = 1.0;\n\n parse_nodes(nodes, &t1.nodes);\n CU_ASSERT_EQUAL_FATAL(t1.nodes.num_rows, 7);\n parse_individuals(individuals, &t1.individuals);\n CU_ASSERT_EQUAL_FATAL(t1.individuals.num_rows, 4);\n tsk_population_table_add_row(&t1.populations, \"A\", 1);\n tsk_population_table_add_row(&t1.populations, \"B\", 1);\n tsk_population_table_add_row(&t1.populations, \"C\", 1);\n parse_edges(single_tree_ex_edges, &t1.edges);\n CU_ASSERT_EQUAL_FATAL(t1.edges.num_rows, 6);\n parse_sites(sites, &t1.sites);\n CU_ASSERT_EQUAL_FATAL(t1.sites.num_rows, 3);\n parse_mutations(mutations, &t1.mutations);\n CU_ASSERT_EQUAL_FATAL(t1.mutations.num_rows, 9);\n\n ret = tsk_table_collection_canonicalise(&t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n parse_nodes(nodes_sorted, &t2.nodes);\n tsk_population_table_add_row(&t2.populations, \"C\", 1);\n tsk_population_table_add_row(&t2.populations, \"A\", 1);\n CU_ASSERT_EQUAL_FATAL(t2.nodes.num_rows, 7);\n parse_individuals(individuals_sorted, &t2.individuals);\n CU_ASSERT_EQUAL_FATAL(t2.individuals.num_rows, 3);\n parse_edges(single_tree_ex_edges, &t2.edges);\n CU_ASSERT_EQUAL_FATAL(t2.edges.num_rows, 6);\n parse_sites(sites_sorted, &t2.sites);\n parse_mutations(mutations_sorted, &t2.mutations);\n CU_ASSERT_EQUAL_FATAL(t2.sites.num_rows, 3);\n CU_ASSERT_EQUAL_FATAL(t2.mutations.num_rows, 9);\n\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n\n ret = tsk_table_collection_clear(&t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_clear(&t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // now with KEEP_UNREFERENCED\n parse_nodes(nodes, &t1.nodes);\n parse_individuals(individuals, &t1.individuals);\n tsk_population_table_add_row(&t1.populations, \"A\", 1);\n tsk_population_table_add_row(&t1.populations, \"B\", 1);\n tsk_population_table_add_row(&t1.populations, \"C\", 1);\n parse_edges(single_tree_ex_edges, &t1.edges);\n parse_sites(sites, &t1.sites);\n parse_mutations(mutations, &t1.mutations);\n\n ret = tsk_table_collection_canonicalise(&t1, TSK_SUBSET_KEEP_UNREFERENCED);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n parse_nodes(nodes_sorted, &t2.nodes);\n tsk_population_table_add_row(&t2.populations, \"C\", 1);\n tsk_population_table_add_row(&t2.populations, \"A\", 1);\n tsk_population_table_add_row(&t2.populations, \"B\", 1);\n parse_individuals(individuals_sorted_kept, &t2.individuals);\n CU_ASSERT_EQUAL_FATAL(t2.individuals.num_rows, 4);\n parse_edges(single_tree_ex_edges, &t2.edges);\n parse_sites(sites_sorted, &t2.sites);\n parse_mutations(mutations_sorted, &t2.mutations);\n\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n\n tsk_table_collection_free(&t2);\n tsk_table_collection_free(&t1);\n}\n\nstatic void\ntest_sort_tables_migrations(void)\n{\n int ret;\n tsk_treeseq_t *ts;\n tsk_table_collection_t tables, copy;\n\n ts = caterpillar_tree(13, 1, 1);\n ret = tsk_treeseq_copy_tables(ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tables.migrations.num_rows > 0);\n\n ret = tsk_table_collection_copy(&tables, ©, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tsk_table_collection_equals(&tables, ©, 0));\n\n reverse_migrations(&tables);\n CU_ASSERT_FATAL(!tsk_table_collection_equals(&tables, ©, 0));\n ret = tsk_table_collection_sort(&tables, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tsk_migration_table_equals(&tables.migrations, ©.migrations, 0));\n CU_ASSERT_FATAL(tsk_table_collection_equals(&tables, ©, 0));\n\n /* Make sure we test the deeper comparison keys. The full key is\n * (time, source, dest, left, node) */\n tsk_migration_table_clear(&tables.migrations);\n\n /* params = left, right, node, source, dest, time */\n tsk_migration_table_add_row(&tables.migrations, 0, 1, 0, 0, 1, 0, NULL, 0);\n tsk_migration_table_add_row(&tables.migrations, 0, 1, 1, 0, 1, 0, NULL, 0);\n ret = tsk_migration_table_copy(&tables.migrations, ©.migrations, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n reverse_migrations(&tables);\n CU_ASSERT_FATAL(!tsk_table_collection_equals(&tables, ©, 0));\n ret = tsk_table_collection_sort(&tables, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tsk_migration_table_equals(&tables.migrations, ©.migrations, 0));\n\n tsk_table_collection_free(&tables);\n tsk_table_collection_free(©);\n tsk_treeseq_free(ts);\n free(ts);\n}\n\nstatic void\ntest_sort_tables_individuals(void)\n{\n int ret;\n tsk_table_collection_t tables, copy;\n const char *individuals = \"1 0.25 2,3 0\\n\"\n \"2 0.5 5,-1 1\\n\"\n \"3 0.3 -1 2\\n\"\n \"4 0.3 -1 3\\n\"\n \"5 0.3 3 4\\n\"\n \"6 0.3 4 5\\n\";\n const char *individuals_cycle = \"1 0.2 2 0\\n\"\n \"2 0.5 0 1\\n\"\n \"3 0.3 1 2\\n\";\n const tsk_id_t bad_parents[] = { 200 };\n tsk_id_t ret_id;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1.0;\n parse_individuals(individuals, &tables.individuals);\n\n ret = tsk_table_collection_copy(&tables, ©, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Table sort doesn't touch individuals by default*/\n ret = tsk_table_collection_sort(&tables, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tsk_table_collection_equals(&tables, ©, 0));\n\n /* Not calling with TSK_CHECK_TREES so casting is safe */\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_INDIVIDUAL_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSORTED_INDIVIDUALS);\n\n ret = tsk_table_collection_individual_topological_sort(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_INDIVIDUAL_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Check that the sort is stable */\n tsk_table_collection_free(©);\n ret = tsk_table_collection_copy(&tables, ©, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_individual_topological_sort(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tsk_table_collection_equals(&tables, ©, 0));\n\n /* Errors on bad table */\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, bad_parents, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 6);\n ret = tsk_table_collection_individual_topological_sort(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n\n /* Errors on cycle */\n tsk_individual_table_clear(&tables.individuals);\n parse_individuals(individuals_cycle, &tables.individuals);\n ret = tsk_table_collection_individual_topological_sort(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_INDIVIDUAL_PARENT_CYCLE);\n\n tsk_table_collection_free(&tables);\n tsk_table_collection_free(©);\n}\n\nstatic void\ntest_sorter_interface(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_table_sorter_t sorter;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, &tables, 0));\n\n /* Nominal case */\n reverse_edges(&tables);\n CU_ASSERT_FALSE(tsk_table_collection_equals(ts.tables, &tables, 0));\n ret = tsk_table_sorter_init(&sorter, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_sorter_run(&sorter, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, &tables, 0));\n CU_ASSERT_EQUAL(sorter.user_data, NULL);\n tsk_table_sorter_free(&sorter);\n\n /* If we set the sort_edges function to NULL then we should leave the\n * node table as is. */\n reverse_edges(&tables);\n CU_ASSERT_FALSE(tsk_edge_table_equals(&ts.tables->edges, &tables.edges, 0));\n ret = tsk_table_sorter_init(&sorter, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n sorter.sort_edges = NULL;\n ret = tsk_table_sorter_run(&sorter, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_edge_table_equals(&ts.tables->edges, &tables.edges, 0));\n tsk_table_sorter_free(&sorter);\n\n /* Reversing again should make them equal */\n reverse_edges(&tables);\n CU_ASSERT_TRUE(tsk_edge_table_equals(&ts.tables->edges, &tables.edges, 0));\n\n /* Do not check integrity before sorting */\n reverse_edges(&tables);\n CU_ASSERT_FALSE(tsk_table_collection_equals(ts.tables, &tables, 0));\n ret = tsk_table_sorter_init(&sorter, &tables, TSK_NO_CHECK_INTEGRITY);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_sorter_run(&sorter, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, &tables, 0));\n tsk_table_sorter_free(&sorter);\n\n /* The user_data shouldn't be touched */\n reverse_edges(&tables);\n CU_ASSERT_FALSE(tsk_table_collection_equals(ts.tables, &tables, 0));\n ret = tsk_table_sorter_init(&sorter, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n sorter.user_data = (void *) &ts;\n ret = tsk_table_sorter_run(&sorter, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, &tables, 0));\n CU_ASSERT_EQUAL_FATAL(sorter.user_data, &ts);\n tsk_table_sorter_free(&sorter);\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_dump_unindexed_with_options(tsk_flags_t tc_options)\n{\n tsk_table_collection_t tables, loaded;\n int ret;\n\n ret = tsk_table_collection_init(&tables, tc_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1;\n parse_nodes(single_tree_ex_nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 7);\n parse_edges(single_tree_ex_edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 6);\n CU_ASSERT_FALSE(tsk_table_collection_has_index(&tables, 0));\n ret = tsk_table_collection_dump(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_has_index(&tables, 0));\n\n ret = tsk_table_collection_load(&loaded, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_has_index(&loaded, 0));\n CU_ASSERT_TRUE(tsk_node_table_equals(&tables.nodes, &loaded.nodes, 0));\n CU_ASSERT_TRUE(tsk_edge_table_equals(&tables.edges, &loaded.edges, 0));\n\n tsk_table_collection_free(&loaded);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_dump_unindexed(void)\n{\n test_dump_unindexed_with_options(0);\n test_dump_unindexed_with_options(TSK_TC_NO_EDGE_METADATA);\n}\n\nstatic void\ntest_dump_load_empty_with_options(tsk_flags_t tc_options)\n{\n int ret;\n tsk_table_collection_t t1, t2;\n\n ret = tsk_table_collection_init(&t1, tc_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n t1.sequence_length = 1.0;\n ret = tsk_table_collection_dump(&t1, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n\n tsk_table_collection_free(&t1);\n tsk_table_collection_free(&t2);\n}\n\nstatic void\ntest_dump_load_empty(void)\n{\n test_dump_load_empty_with_options(0);\n test_dump_load_empty_with_options(TSK_TC_NO_EDGE_METADATA);\n}\n\nstatic void\ntest_dump_load_unsorted_with_options(tsk_flags_t tc_options)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t t1, t2;\n\n ret = tsk_table_collection_init(&t1, tc_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n t1.sequence_length = 1.0;\n\n ret_id = tsk_node_table_add_row(\n &t1.nodes, TSK_NODE_IS_SAMPLE, 0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_node_table_add_row(\n &t1.nodes, TSK_NODE_IS_SAMPLE, 0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_node_table_add_row(\n &t1.nodes, TSK_NODE_IS_SAMPLE, 0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 2);\n ret_id = tsk_node_table_add_row(\n &t1.nodes, TSK_NODE_IS_SAMPLE, 1, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 3);\n ret_id = tsk_node_table_add_row(\n &t1.nodes, TSK_NODE_IS_SAMPLE, 2, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 4);\n\n ret_id = tsk_edge_table_add_row(&t1.edges, 0, 1, 3, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_edge_table_add_row(&t1.edges, 0, 1, 4, 3, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_edge_table_add_row(&t1.edges, 0, 1, 3, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 2);\n ret_id = tsk_edge_table_add_row(&t1.edges, 0, 1, 4, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 3);\n\n /* Verify that it's unsorted */\n ret = (int) tsk_table_collection_check_integrity(&t1, TSK_CHECK_EDGE_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGES_NOT_SORTED_PARENT_TIME);\n\n ret = tsk_table_collection_dump(&t1, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_has_index(&t1, 0));\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n CU_ASSERT_FALSE(tsk_table_collection_has_index(&t1, 0));\n CU_ASSERT_FALSE(tsk_table_collection_has_index(&t2, 0));\n\n tsk_table_collection_free(&t1);\n tsk_table_collection_free(&t2);\n}\n\nstatic void\ntest_dump_load_unsorted(void)\n{\n test_dump_load_unsorted_with_options(0);\n test_dump_load_unsorted_with_options(TSK_TC_NO_EDGE_METADATA);\n}\n\nstatic void\ntest_dump_load_metadata_schema(void)\n{\n int ret;\n tsk_table_collection_t t1, t2;\n\n ret = tsk_table_collection_init(&t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n t1.sequence_length = 1.0;\n char example[100] = \"An example of metadata schema with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_length = (tsk_size_t) strlen(example) + 4;\n tsk_node_table_set_metadata_schema(\n &t1.nodes, strcat(example, \"node\"), example_length);\n tsk_edge_table_set_metadata_schema(\n &t1.edges, strcat(example, \"edge\"), example_length);\n tsk_site_table_set_metadata_schema(\n &t1.sites, strcat(example, \"site\"), example_length);\n tsk_mutation_table_set_metadata_schema(\n &t1.mutations, strcat(example, \"muta\"), example_length);\n tsk_migration_table_set_metadata_schema(\n &t1.migrations, strcat(example, \"migr\"), example_length);\n tsk_individual_table_set_metadata_schema(\n &t1.individuals, strcat(example, \"indi\"), example_length);\n tsk_population_table_set_metadata_schema(\n &t1.populations, strcat(example, \"popu\"), example_length);\n ret = tsk_table_collection_dump(&t1, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&t2, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n\n tsk_table_collection_free(&t1);\n tsk_table_collection_free(&t2);\n}\n\nstatic void\ntest_dump_fail_no_file(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t t1;\n\n ret = tsk_table_collection_init(&t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n t1.sequence_length = 1.0;\n\n ret_id = tsk_node_table_add_row(\n &t1.nodes, TSK_NODE_IS_SAMPLE, 0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_node_table_add_row(\n &t1.nodes, TSK_NODE_IS_SAMPLE, 0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_node_table_add_row(\n &t1.nodes, TSK_NODE_IS_SAMPLE, 0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 2);\n ret_id = tsk_node_table_add_row(\n &t1.nodes, TSK_NODE_IS_SAMPLE, 1, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 3);\n ret_id = tsk_node_table_add_row(\n &t1.nodes, TSK_NODE_IS_SAMPLE, 2, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 4);\n\n ret_id = tsk_edge_table_add_row(&t1.edges, 0, 1, 3, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_edge_table_add_row(&t1.edges, 0, 1, 4, 3, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_edge_table_add_row(&t1.edges, 0, 1, 3, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 2);\n ret_id = tsk_edge_table_add_row(&t1.edges, 0, 1, 4, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 3);\n\n /* Verify that it's unsorted */\n ret = (int) tsk_table_collection_check_integrity(&t1, TSK_CHECK_EDGE_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGES_NOT_SORTED_PARENT_TIME);\n\n /* Make sure the file doesn't exist beforehand. */\n unlink(_tmp_file_name);\n errno = 0;\n\n CU_ASSERT_EQUAL(access(_tmp_file_name, F_OK), -1);\n\n tsk_table_collection_free(&t1);\n}\n\nstatic void\ntest_load_reindex(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_dump(&ts, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_drop_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_has_index(&tables, 0));\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_has_index(&tables, 0));\n\n ret = tsk_table_collection_drop_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Dump the unindexed version */\n ret = tsk_table_collection_dump(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_free(&tables);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_load(&tables, _tmp_file_name, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_has_index(&tables, 0));\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_has_index(&tables, 0));\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_table_overflow(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n tsk_size_t max_rows = ((tsk_size_t) TSK_MAX_ID);\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Simulate overflows */\n tables.individuals.max_rows = max_rows;\n tables.individuals.num_rows = max_rows;\n ret_id\n = tsk_individual_table_add_row(&tables.individuals, 0, 0, 0, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLE_OVERFLOW);\n\n tables.nodes.max_rows = max_rows;\n tables.nodes.num_rows = max_rows;\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLE_OVERFLOW);\n\n tables.edges.max_rows = max_rows;\n tables.edges.num_rows = max_rows;\n ret_id = tsk_edge_table_add_row(&tables.edges, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLE_OVERFLOW);\n\n tables.migrations.max_rows = max_rows;\n tables.migrations.num_rows = max_rows;\n ret_id = tsk_migration_table_add_row(&tables.migrations, 0, 0, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLE_OVERFLOW);\n\n tables.sites.max_rows = max_rows;\n tables.sites.num_rows = max_rows;\n ret_id = tsk_site_table_add_row(&tables.sites, 0, 0, 0, 0, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLE_OVERFLOW);\n\n tables.mutations.max_rows = max_rows;\n tables.mutations.num_rows = max_rows;\n ret_id = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 0, 0, 0, 0, 0, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLE_OVERFLOW);\n\n tables.provenances.max_rows = max_rows;\n tables.provenances.num_rows = max_rows;\n ret_id = tsk_provenance_table_add_row(&tables.provenances, 0, 0, 0, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLE_OVERFLOW);\n\n tables.populations.max_rows = max_rows;\n tables.populations.num_rows = max_rows;\n ret_id = tsk_population_table_add_row(&tables.populations, 0, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLE_OVERFLOW);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_column_overflow(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n tsk_size_t too_big = TSK_MAX_SIZE;\n double zero = 0;\n char zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 };\n tsk_id_t id_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 };\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // location\n /* We can't trigger a column overflow with one element because the parameter\n * value is 32 bit */\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, &zero, 1, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n // Check normal overflow from additional length\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, too_big, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n // Check overflow from minimum increment\n ret = tsk_individual_table_set_max_location_length_increment(\n &tables.individuals, too_big);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 1, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n // parents\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, id_zeros, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, too_big, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n ret = tsk_individual_table_set_max_parents_length_increment(\n &tables.individuals, too_big);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n // metadata\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, zeros, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, 2);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, too_big);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n ret = tsk_individual_table_set_max_metadata_length_increment(\n &tables.individuals, too_big);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, 0, 0, zeros, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, 0, 0, NULL, too_big);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n ret = tsk_node_table_set_max_metadata_length_increment(&tables.nodes, too_big);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, 0, 0, NULL, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n\n ret_id = tsk_edge_table_add_row(&tables.edges, 0, 0, 0, 0, zeros, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0, 0, 0, 0, NULL, too_big);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n ret = tsk_edge_table_set_max_metadata_length_increment(&tables.edges, too_big);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0, 0, 0, 0, NULL, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n\n ret_id = tsk_site_table_add_row(&tables.sites, 0, zeros, 1, zeros, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n // ancestral state\n ret_id = tsk_site_table_add_row(&tables.sites, 0, NULL, too_big, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n ret = tsk_site_table_set_max_ancestral_state_length_increment(\n &tables.sites, too_big);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0, NULL, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n // metadata\n ret_id = tsk_site_table_add_row(&tables.sites, 0, NULL, 0, NULL, too_big);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n ret = tsk_site_table_set_max_metadata_length_increment(&tables.sites, too_big);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0, NULL, 0, NULL, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n\n ret_id\n = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 0, 0, zeros, 1, zeros, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n // derived state\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, 0, 0, NULL, too_big, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n ret = tsk_mutation_table_set_max_derived_state_length_increment(\n &tables.mutations, too_big);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 0, 0, NULL, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n // metadata\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, 0, 0, NULL, 0, NULL, too_big);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n ret = tsk_mutation_table_set_max_metadata_length_increment(\n &tables.mutations, too_big);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(&tables.mutations, 0, 0, 0, 0, NULL, 0, NULL, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n\n ret_id = tsk_provenance_table_add_row(&tables.provenances, zeros, 1, zeros, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0)\n // timestamp\n ret_id = tsk_provenance_table_add_row(&tables.provenances, NULL, too_big, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n ret = tsk_provenance_table_set_max_timestamp_length_increment(\n &tables.provenances, too_big);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_provenance_table_add_row(&tables.provenances, NULL, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n // record\n ret_id = tsk_provenance_table_add_row(&tables.provenances, NULL, 0, NULL, too_big);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n ret = tsk_provenance_table_set_max_record_length_increment(\n &tables.provenances, too_big);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_provenance_table_add_row(&tables.provenances, NULL, 0, NULL, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n\n ret_id = tsk_population_table_add_row(&tables.populations, zeros, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, too_big);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n ret = tsk_population_table_set_max_metadata_length_increment(\n &tables.populations, too_big);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n\n ret_id = tsk_migration_table_add_row(&tables.migrations, 0, 0, 0, 0, 0, 0, zeros, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_migration_table_add_row(\n &tables.migrations, 0, 0, 0, 0, 0, 0, NULL, too_big);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n ret = tsk_migration_table_set_max_metadata_length_increment(\n &tables.migrations, too_big);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_migration_table_add_row(&tables.migrations, 0, 0, 0, 0, 0, 0, NULL, 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_table_collection_check_integrity_with_options(tsk_flags_t tc_options)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n const char *individuals = \"1 0.25 -1\\n\"\n \"2 0.5,0.25 2\\n\"\n \"3 0.5,0.25 0\\n\";\n\n ret = tsk_table_collection_init(&tables, tc_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n /* nodes */\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, INFINITY, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n /* Not calling with TSK_CHECK_TREES so casting is safe */\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TIME_NONFINITE);\n\n ret = tsk_node_table_clear(&tables.nodes);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, 0, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, ret_id);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_NO_CHECK_POPULATION_REFS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n\n ret = tsk_node_table_clear(&tables.nodes);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, ret_id);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n\n ret = tsk_node_table_clear(&tables.nodes);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 1.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* edges */\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, TSK_NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NULL_PARENT);\n\n ret = tsk_edge_table_clear(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, 2, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n ret = tsk_edge_table_clear(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, 1, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NULL_CHILD);\n\n ret = tsk_edge_table_clear(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, 1, 2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n ret = tsk_edge_table_clear(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, INFINITY, 1, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_GENOME_COORDS_NONFINITE);\n\n ret = tsk_edge_table_clear(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, -1.0, 1.0, 1, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_LEFT_LESS_ZERO);\n\n ret = tsk_edge_table_clear(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.1, 1, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_RIGHT_GREATER_SEQ_LENGTH);\n\n ret = tsk_edge_table_clear(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.5, 0.1, 1, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_EDGE_INTERVAL);\n\n ret = tsk_edge_table_clear(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 0.5, 0, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_NODE_TIME_ORDERING);\n\n ret = tsk_edge_table_clear(&tables.edges);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* sites */\n ret_id = tsk_site_table_add_row(&tables.sites, INFINITY, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SITE_POSITION);\n\n ret = tsk_site_table_clear(&tables.sites);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_site_table_add_row(&tables.sites, -0.5, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SITE_POSITION);\n\n ret = tsk_site_table_clear(&tables.sites);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 1.5, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SITE_POSITION);\n\n ret = tsk_site_table_clear(&tables.sites);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.5, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.5, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, TSK_CHECK_SITE_DUPLICATES);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SITE_POSITION);\n\n ret = tsk_site_table_clear(&tables.sites);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.5, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.4, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, TSK_CHECK_SITE_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSORTED_SITES);\n\n ret = tsk_site_table_clear(&tables.sites);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.5, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.6, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n /* mutations */\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 2, 0, TSK_NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 2, TSK_NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n /* A mixture of known and unknown times on a site fails */\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_MUTATION_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_TIME_HAS_BOTH_KNOWN_AND_UNKNOWN);\n\n /* But on different sites, passes */\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 1, 0, TSK_NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_MUTATION_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(&tables.mutations, 0, 1, 2, 0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id\n = tsk_mutation_table_add_row(&tables.mutations, 0, 1, 0, 1.0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_MUTATION_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_PARENT_EQUAL);\n\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id\n = tsk_mutation_table_add_row(&tables.mutations, 0, 1, 1, 1.0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 1, TSK_NULL, 1.0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_MUTATION_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_PARENT_AFTER_CHILD);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 1, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 1, 1, 0, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_MUTATION_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_PARENT_DIFFERENT_SITE);\n\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 1, 1, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 1, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_MUTATION_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSORTED_MUTATIONS);\n\n /* Unknown times pass */\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_MUTATION_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Correctly ordered times pass */\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, 1, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, 1, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_MUTATION_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Incorrectly ordered times fail */\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, 1, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_MUTATION_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSORTED_MUTATIONS);\n\n /* Putting incorrectly ordered times on diff sites passes */\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, 1, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 1, 0, TSK_NULL, 2, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 1, 0, TSK_NULL, 1, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_MUTATION_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, NAN, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TIME_NONFINITE);\n\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, INFINITY, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TIME_NONFINITE);\n\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 1, 1, TSK_NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_MUTATION_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_TIME_YOUNGER_THAN_NODE);\n\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 1, 1, TSK_NULL, 1, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(&tables.mutations, 1, 1, 0, 2, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_MUTATION_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_TIME_OLDER_THAN_PARENT_MUTATION);\n ret = tsk_mutation_table_clear(&tables.mutations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_MUTATION_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* migrations */\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_migration_table_clear(&tables.migrations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_migration_table_add_row(\n &tables.migrations, 0.0, 0.5, 2, 0, 1, 1.5, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n ret = tsk_migration_table_clear(&tables.migrations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_migration_table_add_row(\n &tables.migrations, 0.0, 0.5, 1, 2, 1, 1.5, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n\n ret = tsk_migration_table_clear(&tables.migrations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_migration_table_add_row(\n &tables.migrations, 0.0, 0.5, 1, 0, 2, 1.5, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n\n ret = tsk_migration_table_clear(&tables.migrations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_migration_table_add_row(\n &tables.migrations, 0.0, 0.5, 1, 0, 1, INFINITY, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TIME_NONFINITE);\n\n ret = tsk_migration_table_clear(&tables.migrations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_migration_table_add_row(\n &tables.migrations, 0.0, 0.5, 1, 0, 1, 1.5, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_migration_table_add_row(\n &tables.migrations, 0.0, 0.5, 1, 1, 0, 0.5, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_MIGRATION_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSORTED_MIGRATIONS);\n\n ret = tsk_migration_table_clear(&tables.migrations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_migration_table_add_row(\n &tables.migrations, 0.0, INFINITY, 1, 0, 1, 1.5, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_GENOME_COORDS_NONFINITE);\n\n ret = tsk_migration_table_clear(&tables.migrations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_migration_table_add_row(\n &tables.migrations, -0.3, 0.5, 1, 0, 1, 1.5, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_LEFT_LESS_ZERO);\n\n ret = tsk_migration_table_clear(&tables.migrations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_migration_table_add_row(\n &tables.migrations, 0.0, 1.5, 1, 0, 1, 1.5, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_RIGHT_GREATER_SEQ_LENGTH);\n\n ret = tsk_migration_table_clear(&tables.migrations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_migration_table_add_row(\n &tables.migrations, 0.6, 0.5, 1, 0, 1, 1.5, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_EDGE_INTERVAL);\n ret = tsk_migration_table_clear(&tables.migrations);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n parse_individuals(individuals, &tables.individuals);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.num_rows, 3);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_INDIVIDUAL_ORDERING);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSORTED_INDIVIDUALS);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Check that an individual can't be its own parent */\n tables.individuals.parents[0] = 0;\n tables.individuals.parents[1] = 1;\n tables.individuals.parents[2] = 2;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_SELF_PARENT);\n\n tables.individuals.parents[0] = -2;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_table_collection_check_integrity_no_populations(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_id_t ret_num_trees;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Add in some bad population references and check that we can use\n * TSK_NO_CHECK_POPULATION_REFS with TSK_CHECK_TREES */\n tables.nodes.population[0] = 10;\n /* Not calling with TSK_CHECK_TREES so casting is safe */\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n ret_num_trees = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n CU_ASSERT_EQUAL_FATAL(ret_num_trees, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_NO_CHECK_POPULATION_REFS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_num_trees = tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_TREES | TSK_NO_CHECK_POPULATION_REFS);\n /* CHECK_TREES returns the number of trees */\n CU_ASSERT_EQUAL_FATAL(ret_num_trees, 3);\n tables.nodes.population[0] = TSK_NULL;\n\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_migration_table_add_row(\n &tables.migrations, 0.4, 0.5, 1, 0, 1, 1.5, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n ret_num_trees = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n CU_ASSERT_EQUAL_FATAL(ret_num_trees, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n ret = (int) tsk_table_collection_check_integrity(\n &tables, TSK_NO_CHECK_POPULATION_REFS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_num_trees = tsk_table_collection_check_integrity(\n &tables, TSK_CHECK_TREES | TSK_NO_CHECK_POPULATION_REFS);\n CU_ASSERT_EQUAL_FATAL(ret_num_trees, 3);\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_table_collection_check_integrity(void)\n{\n test_table_collection_check_integrity_with_options(0);\n test_table_collection_check_integrity_with_options(TSK_TC_NO_EDGE_METADATA);\n}\n\nstatic void\ntest_table_collection_check_integrity_bad_indexes_example(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n\n /* We start with a concrete example where you can get bad trees\n * by building some valid tables, clearing the edges, and then\n * building new ones without rebuilding the indexes. */\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 5;\n /* nodes */\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 1.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 2);\n /* edges */\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 5.0, 2, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 5.0, 2, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n /* build index */\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* okay now build a new table without rebuilding the indexes */\n tsk_edge_table_clear(&tables.edges);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, 2, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /* make sure we don't use too-long indexes */\n ret_id = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLES_NOT_INDEXED);\n\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 4.0, 2, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n\n /* should error, as tree sequence will be wrong */\n ret_id = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLES_BAD_INDEXES);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_table_collection_check_integrity_bad_indexes(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n\n /* Now hit some other weird cases by manipulating the indexes directly */\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 5;\n /* nodes */\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 1.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 2);\n /* edges */\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, 2, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 1.0, 2.0, 2, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_edge_table_add_row(&tables.edges, 2.0, 5.0, 2, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 2);\n ret_id = tsk_edge_table_add_row(&tables.edges, 1.0, 3.0, 2, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 3);\n /* build index */\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n CU_ASSERT(ret_id > 0);\n\n /* edge removed before it is added */\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.indexes.edge_insertion_order[0] = 1;\n tables.indexes.edge_insertion_order[2] = 0;\n ret_id = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLES_BAD_INDEXES);\n\n /* edge added twice (implies another is never added) */\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.indexes.edge_insertion_order[0] = 0;\n tables.indexes.edge_insertion_order[1] = 0;\n tables.indexes.edge_removal_order[0] = 1;\n tables.indexes.edge_removal_order[2] = 2;\n ret_id = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLES_BAD_INDEXES);\n\n /* edge never removed but should have been */\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.indexes.edge_removal_order[0] = 0;\n tables.indexes.edge_removal_order[1] = 1;\n tables.indexes.edge_removal_order[2] = 2;\n tables.indexes.edge_removal_order[3] = 3;\n ret_id = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLES_BAD_INDEXES);\n\n /* edge progression out of order */\n tables.edges.right[2] = 4.0;\n ret_id = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLES_BAD_INDEXES);\n\n /* edge never used */\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.indexes.edge_insertion_order[0] = 0;\n tables.indexes.edge_insertion_order[1] = 3;\n tables.indexes.edge_insertion_order[2] = 0;\n tables.indexes.edge_insertion_order[3] = 3;\n tables.indexes.edge_removal_order[0] = 0;\n tables.indexes.edge_removal_order[1] = 3;\n tables.indexes.edge_removal_order[2] = 0;\n tables.indexes.edge_removal_order[3] = 3;\n ret_id = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLES_BAD_INDEXES);\n\n /* make sure we don't use the too-short indexes */\n ret_id = tsk_edge_table_add_row(&tables.edges, 4.0, 5.0, 2, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 4);\n ret_id = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_TABLES_NOT_INDEXED);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_check_integrity_bad_mutation_parent_topology(void)\n{\n int ret;\n tsk_id_t ret_trees;\n tsk_table_collection_t tables;\n const char *sites = \"0 0\\n\";\n /* Make a mutation on a parallel branch the parent*/\n const char *bad_mutations = \"0 0 1 -1\\n\"\n \"0 1 1 0\\n\";\n\n /* A mutation above is set as child*/\n const char *reverse_mutations = \"0 0 1 -1\\n\"\n \"0 4 1 0\\n\";\n\n const char *reverse_sites = \"0.5 0\\n\"\n \"0 0\\n\";\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1;\n parse_nodes(single_tree_ex_nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 7);\n parse_edges(single_tree_ex_edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 6);\n parse_sites(sites, &tables.sites);\n CU_ASSERT_EQUAL_FATAL(tables.sites.num_rows, 1);\n parse_mutations(bad_mutations, &tables.mutations);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.num_rows, 2);\n tables.sequence_length = 1.0;\n\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_trees = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n CU_ASSERT_EQUAL_FATAL(ret_trees, 1);\n ret_trees\n = tsk_table_collection_check_integrity(&tables, TSK_CHECK_MUTATION_PARENTS);\n CU_ASSERT_EQUAL_FATAL(ret_trees, TSK_ERR_BAD_MUTATION_PARENT);\n\n parse_mutations(reverse_mutations, &tables.mutations);\n ret_trees = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n CU_ASSERT_EQUAL_FATAL(ret_trees, 1);\n ret_trees\n = tsk_table_collection_check_integrity(&tables, TSK_CHECK_MUTATION_PARENTS);\n CU_ASSERT_EQUAL_FATAL(ret_trees, TSK_ERR_MUTATION_PARENT_AFTER_CHILD);\n\n /* Now check that TSK_CHECK_MUTATION_PARENTS implies TSK_CHECK_TREES\n by triggering an error with reversed sites */\n parse_sites(reverse_sites, &tables.sites);\n ret_trees\n = tsk_table_collection_check_integrity(&tables, TSK_CHECK_MUTATION_PARENTS);\n CU_ASSERT_EQUAL_FATAL(ret_trees, TSK_ERR_UNSORTED_SITES);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_table_collection_compute_mutation_parents_tolerates_invalid_input(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n tsk_id_t site;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1.0;\n\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 1.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, 0, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n site = tsk_site_table_add_row(&tables.sites, 0.0, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(site >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, site, 1, TSK_NULL, TSK_UNKNOWN_TIME, \"C\", 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.mutations.parent[0] = 42;\n\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tables.mutations.parent[0] == TSK_NULL);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_table_collection_compute_mutation_parents_restores_on_error(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n tsk_id_t site;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1.0;\n\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 1.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, 0, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n site = tsk_site_table_add_row(&tables.sites, 0.5, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(site >= 0);\n\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, site, 1, TSK_NULL, TSK_UNKNOWN_TIME, \"C\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, site, 0, TSK_NULL, TSK_UNKNOWN_TIME, \"G\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.mutations.parent[0] = 111;\n tables.mutations.parent[1] = 222;\n\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_PARENT_AFTER_CHILD);\n CU_ASSERT_EQUAL(tables.mutations.parent[0], 111);\n CU_ASSERT_EQUAL(tables.mutations.parent[1], 222);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_table_collection_subset_with_options(tsk_flags_t options)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n tsk_table_collection_t tables_copy;\n int k;\n tsk_id_t nodes[4];\n tsk_id_t zero_p[] = { 0 };\n tsk_id_t one_p[] = { 1 };\n\n ret = tsk_table_collection_init(&tables, options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n ret = tsk_table_collection_init(&tables_copy, options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // does not error on empty tables\n ret = tsk_table_collection_subset(&tables, NULL, 0, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // four nodes from two diploids; the first is from pop 0\n ret_id\n = tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, 0, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 1.0, 0, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 2.0, TSK_NULL, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n // unused individual who is the parent of others\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, zero_p, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, one_p, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n // unused individual\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, one_p, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n // unused population\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, 1, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, 2, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.2, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.4, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n // unused site\n ret_id = tsk_site_table_add_row(&tables.sites, 0.5, \"C\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, 0, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 1, 1, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n // empty nodes should get empty tables\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT | options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_subset(&tables_copy, NULL, 0, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables_copy.nodes.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(tables_copy.individuals.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(tables_copy.populations.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(tables_copy.sites.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(tables_copy.mutations.num_rows, 0);\n\n // unless NO_CHANGE_POPULATIONS is provided\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT | options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_subset(\n &tables_copy, NULL, 0, TSK_SUBSET_NO_CHANGE_POPULATIONS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables_copy.nodes.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(tables_copy.individuals.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(tables_copy.sites.num_rows, 0);\n CU_ASSERT_EQUAL_FATAL(tables_copy.mutations.num_rows, 0);\n CU_ASSERT_FATAL(\n tsk_population_table_equals(&tables.populations, &tables_copy.populations, 0));\n\n // or KEEP_UNREFERENCED\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT | options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_subset(\n &tables_copy, NULL, 0, TSK_SUBSET_KEEP_UNREFERENCED);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables_copy.nodes.num_rows, 0);\n CU_ASSERT_FATAL(\n tsk_individual_table_equals(&tables.individuals, &tables_copy.individuals, 0));\n CU_ASSERT_EQUAL_FATAL(tables_copy.populations.num_rows, 2);\n CU_ASSERT_EQUAL_FATAL(tables_copy.mutations.num_rows, 0);\n CU_ASSERT_FATAL(tsk_site_table_equals(&tables.sites, &tables_copy.sites, 0));\n\n // or both\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT | options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_subset(&tables_copy, NULL, 0,\n TSK_SUBSET_KEEP_UNREFERENCED | TSK_SUBSET_NO_CHANGE_POPULATIONS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables_copy.nodes.num_rows, 0);\n CU_ASSERT_FATAL(\n tsk_individual_table_equals(&tables.individuals, &tables_copy.individuals, 0));\n CU_ASSERT_EQUAL_FATAL(tables_copy.mutations.num_rows, 0);\n CU_ASSERT_FATAL(\n tsk_population_table_equals(&tables.populations, &tables_copy.populations, 0));\n CU_ASSERT_FATAL(tsk_site_table_equals(&tables.sites, &tables_copy.sites, 0));\n\n // the identity transformation, since unused pops are at the end\n for (k = 0; k < 4; k++) {\n nodes[k] = k;\n }\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT | options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_subset(\n &tables_copy, nodes, 4, TSK_SUBSET_KEEP_UNREFERENCED);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tsk_table_collection_equals(&tables, &tables_copy, 0));\n\n // or, remove unused things:\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT | options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_subset(&tables_copy, nodes, 4, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables_copy, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tsk_node_table_equals(&tables.nodes, &tables_copy.nodes, 0));\n CU_ASSERT_EQUAL_FATAL(tables_copy.individuals.num_rows, 2);\n CU_ASSERT_EQUAL_FATAL(tables_copy.populations.num_rows, 1);\n CU_ASSERT_EQUAL_FATAL(tables_copy.sites.num_rows, 2);\n CU_ASSERT_FATAL(\n tsk_mutation_table_equals(&tables.mutations, &tables_copy.mutations, 0));\n\n // reverse twice should get back to the start, since unused pops are at the end\n for (k = 0; k < 4; k++) {\n nodes[k] = 3 - k;\n }\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT | options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_subset(\n &tables_copy, nodes, 4, TSK_SUBSET_KEEP_UNREFERENCED);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_subset(\n &tables_copy, nodes, 4, TSK_SUBSET_KEEP_UNREFERENCED);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables_copy, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tsk_table_collection_equals(&tables, &tables_copy, 0));\n\n tsk_table_collection_free(&tables_copy);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_table_collection_subset(void)\n{\n test_table_collection_subset_with_options(0);\n test_table_collection_subset_with_options(TSK_TC_NO_EDGE_METADATA);\n}\n\nstatic void\ntest_table_collection_subset_unsorted(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n tsk_table_collection_t tables_copy;\n int k;\n tsk_id_t nodes[3];\n tsk_id_t one_p[] = { 1 };\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n ret = tsk_table_collection_init(&tables_copy, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // these tables are a big mess\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.5, TSK_NULL, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 1.0, TSK_NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, one_p, 1, NULL, 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 0.5, 2, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, 1, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.5, 1.0, 2, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.2, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.4, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, 2, TSK_UNKNOWN_TIME, \"B\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 1, 1, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n // but still, this should leave them unchanged\n for (k = 0; k < 3; k++) {\n nodes[k] = k;\n }\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_subset(\n &tables_copy, nodes, 3, TSK_SUBSET_KEEP_UNREFERENCED);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tsk_table_collection_equals(&tables, &tables_copy, 0));\n\n tsk_table_collection_free(&tables_copy);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_table_collection_subset_errors(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n tsk_table_collection_t tables_copy;\n tsk_id_t nodes[4] = { 0, 1, 2, 3 };\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n ret = tsk_table_collection_init(&tables_copy, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // four nodes from two diploids; the first is from pop 0\n ret_id\n = tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, 0, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 1.0, 0, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 2.0, TSK_NULL, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, 1, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Migrations are not supported */\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_migration_table_add_row(&tables_copy.migrations, 0, 1, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables_copy.migrations.num_rows, 1);\n ret = tsk_table_collection_subset(&tables_copy, nodes, 4, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATIONS_NOT_SUPPORTED);\n\n // test out of bounds nodes\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n nodes[0] = -1;\n ret = tsk_table_collection_subset(&tables_copy, nodes, 4, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n nodes[0] = 6;\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_subset(&tables_copy, nodes, 4, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n // check integrity\n nodes[0] = 0;\n nodes[1] = 1;\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_node_table_truncate(&tables_copy.nodes, 3);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_node_table_add_row(\n &tables_copy.nodes, TSK_NODE_IS_SAMPLE, 0.0, -2, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = tsk_table_collection_subset(&tables_copy, nodes, 4, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n\n tsk_table_collection_free(&tables);\n tsk_table_collection_free(&tables_copy);\n}\n\nstatic void\ntest_table_collection_union(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n tsk_table_collection_t tables_empty;\n tsk_table_collection_t tables_copy;\n tsk_id_t node_mapping[3];\n tsk_id_t parents[2] = { -1, -1 };\n char example_metadata[100] = \"An example of metadata with unicode 🎄🌳🌴🌲🎋\";\n tsk_size_t example_metadata_length = (tsk_size_t) strlen(example_metadata);\n\n tsk_memset(node_mapping, 0xff, sizeof(node_mapping));\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n ret = tsk_table_collection_init(&tables_empty, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables_empty.sequence_length = 1;\n ret = tsk_table_collection_init(&tables_copy, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // does not error on empty tables\n ret = tsk_table_collection_union(&tables, &tables_empty, node_mapping, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // does not error on empty tables but that differ on top level metadata\n ret = tsk_table_collection_set_metadata(\n &tables, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_union(&tables, &tables_empty, node_mapping, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // three nodes, two pop, three ind, two edge, two site, two mut\n ret_id\n = tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, 0, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, 1, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 0.5, 1, 2, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, parents, 2, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n parents[0] = 0;\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, parents, 2, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n parents[1] = 1;\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, parents, 2, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, 2, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, 2, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.4, \"T\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.2, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 1, 1, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_sort(&tables, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // union with empty should not change\n // other is empty\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_union(\n &tables_copy, &tables_empty, node_mapping, TSK_UNION_NO_CHECK_SHARED);\n CU_ASSERT_FATAL(tsk_table_collection_equals(&tables, &tables_copy, 0));\n // self is empty\n ret = tsk_table_collection_clear(&tables_copy, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_union(\n &tables_copy, &tables, node_mapping, TSK_UNION_NO_CHECK_SHARED);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tsk_table_collection_equals(&tables, &tables_copy, 0));\n\n // union all shared nodes + subset original nodes = original table\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_union(\n &tables_copy, &tables, node_mapping, TSK_UNION_NO_CHECK_SHARED);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n node_mapping[0] = 0;\n node_mapping[1] = 1;\n node_mapping[2] = 2;\n ret = tsk_table_collection_subset(&tables_copy, node_mapping, 3, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(tsk_table_collection_equals(&tables, &tables_copy, 0));\n\n // union with one shared node\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n node_mapping[0] = TSK_NULL;\n node_mapping[1] = TSK_NULL;\n node_mapping[2] = 2;\n ret = tsk_table_collection_union(&tables_copy, &tables, node_mapping, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(\n tables_copy.populations.num_rows, tables.populations.num_rows + 2);\n CU_ASSERT_EQUAL_FATAL(\n tables_copy.individuals.num_rows, tables.individuals.num_rows + 2);\n CU_ASSERT_EQUAL_FATAL(tables_copy.nodes.num_rows, tables.nodes.num_rows + 2);\n CU_ASSERT_EQUAL_FATAL(tables_copy.edges.num_rows, tables.edges.num_rows + 2);\n CU_ASSERT_EQUAL_FATAL(tables_copy.sites.num_rows, tables.sites.num_rows);\n CU_ASSERT_EQUAL_FATAL(tables_copy.mutations.num_rows, tables.mutations.num_rows + 2);\n\n // union with one shared node, but no add pop\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n node_mapping[0] = TSK_NULL;\n node_mapping[1] = TSK_NULL;\n node_mapping[2] = 2;\n ret = tsk_table_collection_union(\n &tables_copy, &tables, node_mapping, TSK_UNION_NO_ADD_POP);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables_copy.populations.num_rows, tables.populations.num_rows);\n CU_ASSERT_EQUAL_FATAL(\n tables_copy.individuals.num_rows, tables.individuals.num_rows + 2);\n CU_ASSERT_EQUAL_FATAL(tables_copy.nodes.num_rows, tables.nodes.num_rows + 2);\n CU_ASSERT_EQUAL_FATAL(tables_copy.edges.num_rows, tables.edges.num_rows + 2);\n CU_ASSERT_EQUAL_FATAL(tables_copy.sites.num_rows, tables.sites.num_rows);\n CU_ASSERT_EQUAL_FATAL(tables_copy.mutations.num_rows, tables.mutations.num_rows + 2);\n\n tsk_table_collection_free(&tables_copy);\n tsk_table_collection_free(&tables_empty);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_table_collection_disjoint_union(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n tsk_table_collection_t tables1;\n tsk_table_collection_t tables2;\n tsk_table_collection_t tables12;\n tsk_id_t node_mapping[4];\n\n tsk_memset(node_mapping, 0xff, sizeof(node_mapping));\n\n ret = tsk_table_collection_init(&tables1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables1.sequence_length = 2;\n\n // set up nodes, which will be shared\n // flags, time, pop, ind, metadata, metadata_length\n ret_id = tsk_node_table_add_row(\n &tables1.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tables1.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(&tables1.nodes, 0, 0.5, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_node_table_add_row(&tables1.nodes, 0, 1.5, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = tsk_table_collection_copy(&tables1, &tables2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // for tables1:\n // on [0, 1] we have 0, 1 inherit from 2\n // left, right, parent, child, metadata, metadata_length\n ret_id = tsk_edge_table_add_row(&tables1.edges, 0.0, 1.0, 2, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tables1.edges, 0.0, 1.0, 2, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables1.sites, 0.4, \"T\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables1.mutations, ret_id, 0, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = tsk_table_collection_build_index(&tables1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_sort(&tables1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // all this goes in tables12 so far\n ret = tsk_table_collection_copy(&tables1, &tables12, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // for tables2; and need to add to tables12 also:\n // on [1, 2] we have 0, 1 inherit from 3\n // left, right, parent, child, metadata, metadata_length\n ret_id = tsk_edge_table_add_row(&tables2.edges, 1.0, 2.0, 3, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tables2.edges, 1.0, 2.0, 3, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables2.sites, 1.4, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables2.mutations, ret_id, 1, TSK_NULL, TSK_UNKNOWN_TIME, \"T\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = tsk_table_collection_build_index(&tables2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_sort(&tables2, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n // also tables12\n ret_id = tsk_edge_table_add_row(&tables12.edges, 1.0, 2.0, 3, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tables12.edges, 1.0, 2.0, 3, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables12.sites, 1.4, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables12.mutations, ret_id, 1, TSK_NULL, TSK_UNKNOWN_TIME, \"T\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = tsk_table_collection_build_index(&tables12, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_sort(&tables12, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // now disjoint union-ing tables1 and tables2 should get tables12\n ret = tsk_table_collection_copy(&tables1, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n node_mapping[0] = 0;\n node_mapping[1] = 1;\n node_mapping[2] = 2;\n node_mapping[3] = 3;\n ret = tsk_table_collection_union(&tables, &tables2, node_mapping,\n TSK_UNION_NO_CHECK_SHARED | TSK_UNION_ALL_EDGES | TSK_UNION_ALL_MUTATIONS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FATAL(\n tsk_table_collection_equals(&tables, &tables12, TSK_CMP_IGNORE_PROVENANCE));\n\n tsk_table_collection_free(&tables12);\n tsk_table_collection_free(&tables2);\n tsk_table_collection_free(&tables1);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_table_collection_union_middle_merge(void)\n{\n /* Test ability to have non-shared history both above and below the\n * shared bits. The full genealogy, in `tu`, is:\n * 3 4\n * \\ /\n * 2\n * / \\\n * 0 1\n * and the left lineage is in `ta` and right in `tb` */\n int ret;\n tsk_id_t ret_id;\n tsk_id_t node_mapping[] = { TSK_NULL, 1, TSK_NULL };\n tsk_id_t node_order[] = { 0, 3, 1, 2, 4 };\n tsk_table_collection_t ta, tb, tu;\n ret = tsk_table_collection_init(&ta, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ta.sequence_length = 1;\n ret = tsk_table_collection_init(&tb, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tb.sequence_length = 1;\n ret = tsk_table_collection_init(&tu, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tu.sequence_length = 1;\n\n ret_id = tsk_node_table_add_row(\n &tu.nodes, TSK_NODE_IS_SAMPLE, 0, TSK_NULL, TSK_NULL, NULL, 0); // node u0\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &ta.nodes, TSK_NODE_IS_SAMPLE, 0, TSK_NULL, TSK_NULL, NULL, 0); // node a0 = u0\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tu.nodes, TSK_NODE_IS_SAMPLE, 0, TSK_NULL, TSK_NULL, NULL, 0); // node u1\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tb.nodes, TSK_NODE_IS_SAMPLE, 0, TSK_NULL, TSK_NULL, NULL, 0); // node b0 = u1\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tu.nodes, 0, 1, TSK_NULL, TSK_NULL, NULL, 0); // node u2\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tu.edges, 0, 1, 2, 0, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tu.edges, 0, 1, 2, 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &ta.nodes, 0, 1, TSK_NULL, TSK_NULL, NULL, 0); // node a1 = u2\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&ta.edges, 0, 1, 1, 0, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tb.nodes, 0, 1, TSK_NULL, TSK_NULL, NULL, 0); // node b1 = u2\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tb.edges, 0, 1, 1, 0, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tu.nodes, 0, 2, TSK_NULL, TSK_NULL, NULL, 0); // node u3\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tu.edges, 0, 0.5, 3, 2, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &ta.nodes, 0, 2, TSK_NULL, TSK_NULL, NULL, 0); // node a2 = u3\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&ta.edges, 0, 0.5, 2, 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tu.nodes, 0, 2, TSK_NULL, TSK_NULL, NULL, 0); // node u4\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tu.edges, 0.5, 1, 4, 2, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_node_table_add_row(\n &tb.nodes, 0, 2, TSK_NULL, TSK_NULL, NULL, 0); // node b2 = u4\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tb.edges, 0.5, 1, 2, 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n\n ret_id = tsk_site_table_add_row(&ta.sites, 0.25, \"A\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&ta.sites, 0.75, \"X\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tb.sites, 0.25, \"A\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tb.sites, 0.75, \"X\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tu.sites, 0.25, \"A\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tu.sites, 0.75, \"X\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n\n ret_id = tsk_mutation_table_add_row(\n &tu.mutations, 0, 3, TSK_NULL, 3.5, \"B\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &ta.mutations, 0, 2, TSK_NULL, 3.5, \"B\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tu.mutations, 0, 2, TSK_NULL, 1.5, \"D\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &ta.mutations, 0, 1, TSK_NULL, 1.5, \"D\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tb.mutations, 0, 1, TSK_NULL, 1.5, \"D\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tu.mutations, 0, 2, TSK_NULL, 1.2, \"E\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &ta.mutations, 0, 1, TSK_NULL, 1.2, \"E\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tb.mutations, 0, 1, TSK_NULL, 1.2, \"E\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tu.mutations, 0, 0, TSK_NULL, 0.5, \"C\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &ta.mutations, 0, 0, TSK_NULL, 0.5, \"C\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tu.mutations, 1, 4, TSK_NULL, 2.4, \"Y\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tb.mutations, 1, 2, TSK_NULL, 2.4, \"Y\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tu.mutations, 1, 1, TSK_NULL, 0.4, \"Z\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tb.mutations, 1, 0, TSK_NULL, 0.4, \"Z\", 1, NULL, 0);\n CU_ASSERT(ret_id >= 0);\n\n ret = tsk_table_collection_build_index(&ta, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_compute_mutation_parents(&ta, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_build_index(&tb, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_compute_mutation_parents(&tb, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_build_index(&tu, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_compute_mutation_parents(&tu, 0);\n CU_ASSERT_EQUAL(ret, 0);\n\n ret = tsk_table_collection_union(&ta, &tb, node_mapping, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_table_collection_subset(&ta, node_order, 5, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_provenance_table_clear(&ta.provenances);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_FATAL(tsk_table_collection_equals(&tu, &ta, 0));\n\n tsk_table_collection_free(&ta);\n tsk_table_collection_free(&tb);\n tsk_table_collection_free(&tu);\n}\n\nstatic void\ntest_table_collection_union_errors(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n tsk_table_collection_t tables_copy;\n tsk_id_t node_mapping[] = { 0, 1 };\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n ret = tsk_table_collection_init(&tables_copy, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n // two nodes, two pop, two ind, one edge, one site, one mut\n ret_id\n = tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, 0, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 0.5, 1, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, 1, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.2, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n // trigger diff histories error\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id = tsk_mutation_table_add_row(\n &tables_copy.mutations, 0, 1, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = tsk_table_collection_union(&tables_copy, &tables, node_mapping, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNION_DIFF_HISTORIES);\n\n // Migrations are not supported\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_migration_table_add_row(&tables_copy.migrations, 0, 1, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(tables_copy.migrations.num_rows, 1);\n ret = tsk_table_collection_union(\n &tables_copy, &tables, node_mapping, TSK_UNION_NO_CHECK_SHARED);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATIONS_NOT_SUPPORTED);\n\n // test out of bounds node_mapping\n node_mapping[0] = -4;\n node_mapping[1] = 6;\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_union(&tables_copy, &tables, node_mapping, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNION_BAD_MAP);\n\n // check integrity\n node_mapping[0] = 0;\n node_mapping[1] = 1;\n ret_id = tsk_node_table_add_row(\n &tables_copy.nodes, TSK_NODE_IS_SAMPLE, 0.0, -2, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = tsk_table_collection_union(&tables_copy, &tables, node_mapping, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n ret = tsk_table_collection_copy(&tables, &tables_copy, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_id\n = tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, -2, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret = tsk_table_collection_union(&tables, &tables_copy, node_mapping, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n\n tsk_table_collection_free(&tables_copy);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_table_collection_clear_with_options(tsk_flags_t options)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n bool clear_provenance = !!(options & TSK_CLEAR_PROVENANCE);\n bool clear_metadata_schemas = !!(options & TSK_CLEAR_METADATA_SCHEMAS);\n bool clear_ts_metadata = !!(options & TSK_CLEAR_TS_METADATA_AND_SCHEMA);\n tsk_bookmark_t num_rows;\n tsk_bookmark_t expected_rows = { .provenances = clear_provenance ? 0 : 1 };\n tsk_size_t expected_len = clear_metadata_schemas ? 0 : 4;\n tsk_size_t expected_len_ts = clear_ts_metadata ? 0 : 4;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n ret_id\n = tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, 0, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id\n = tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 0.5, 1, 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0.0, 1.0, 1, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0.2, \"A\", 1, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, TSK_UNKNOWN_TIME, NULL, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_migration_table_add_row(&tables.migrations, 0, 1, 0, 0, 0, 0, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_individual_table_set_metadata_schema(&tables.individuals, \"test\", 4);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_node_table_set_metadata_schema(&tables.nodes, \"test\", 4);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_edge_table_set_metadata_schema(&tables.edges, \"test\", 4);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_migration_table_set_metadata_schema(&tables.migrations, \"test\", 4);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_site_table_set_metadata_schema(&tables.sites, \"test\", 4);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_mutation_table_set_metadata_schema(&tables.mutations, \"test\", 4);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_population_table_set_metadata_schema(&tables.populations, \"test\", 4);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_set_time_units(&tables, \"test\", 4);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_set_metadata(&tables, \"test\", 4);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_set_metadata_schema(&tables, \"test\", 4);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_provenance_table_add_row(&tables.provenances, \"today\", 5, \"test\", 4);\n CU_ASSERT_FATAL(ret_id >= 0);\n\n ret = tsk_table_collection_clear(&tables, options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_record_num_rows(&tables, &num_rows);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(num_rows.individuals, expected_rows.individuals);\n CU_ASSERT_EQUAL(num_rows.nodes, expected_rows.nodes);\n CU_ASSERT_EQUAL(num_rows.edges, expected_rows.edges);\n CU_ASSERT_EQUAL(num_rows.migrations, expected_rows.migrations);\n CU_ASSERT_EQUAL(num_rows.sites, expected_rows.sites);\n CU_ASSERT_EQUAL(num_rows.mutations, expected_rows.mutations);\n CU_ASSERT_EQUAL(num_rows.populations, expected_rows.populations);\n CU_ASSERT_EQUAL(num_rows.provenances, expected_rows.provenances);\n\n CU_ASSERT_FALSE(tsk_table_collection_has_index(&tables, 0));\n\n CU_ASSERT_EQUAL(tables.individuals.metadata_schema_length, expected_len);\n CU_ASSERT_EQUAL(tables.nodes.metadata_schema_length, expected_len);\n CU_ASSERT_EQUAL(tables.edges.metadata_schema_length, expected_len);\n CU_ASSERT_EQUAL(tables.migrations.metadata_schema_length, expected_len);\n CU_ASSERT_EQUAL(tables.sites.metadata_schema_length, expected_len);\n CU_ASSERT_EQUAL(tables.mutations.metadata_schema_length, expected_len);\n CU_ASSERT_EQUAL(tables.populations.metadata_schema_length, expected_len);\n CU_ASSERT_EQUAL(tables.metadata_schema_length, expected_len_ts);\n CU_ASSERT_EQUAL(tables.metadata_length, expected_len_ts);\n CU_ASSERT_EQUAL(tables.time_units_length, 4);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_table_collection_clear(void)\n{\n test_table_collection_clear_with_options(0);\n test_table_collection_clear_with_options(TSK_CLEAR_PROVENANCE);\n test_table_collection_clear_with_options(TSK_CLEAR_METADATA_SCHEMAS);\n test_table_collection_clear_with_options(TSK_CLEAR_TS_METADATA_AND_SCHEMA);\n test_table_collection_clear_with_options(\n TSK_CLEAR_PROVENANCE | TSK_CLEAR_METADATA_SCHEMAS);\n test_table_collection_clear_with_options(\n TSK_CLEAR_PROVENANCE | TSK_CLEAR_TS_METADATA_AND_SCHEMA);\n test_table_collection_clear_with_options(\n TSK_CLEAR_METADATA_SCHEMAS | TSK_CLEAR_TS_METADATA_AND_SCHEMA);\n test_table_collection_clear_with_options(TSK_CLEAR_PROVENANCE\n | TSK_CLEAR_METADATA_SCHEMAS\n | TSK_CLEAR_TS_METADATA_AND_SCHEMA);\n}\n\nstatic void\ntest_table_collection_takeset_indexes(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t t1, t2;\n tsk_id_t *ins;\n tsk_id_t *rem;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ins = tsk_malloc(t1.edges.num_rows * sizeof(*ins));\n CU_ASSERT_FATAL(ins != NULL);\n rem = tsk_malloc(t1.edges.num_rows * sizeof(*rem));\n CU_ASSERT_FATAL(rem != NULL);\n memcpy(ins, t1.indexes.edge_insertion_order,\n (size_t) (t1.edges.num_rows * sizeof(*ins)));\n memcpy(\n rem, t1.indexes.edge_removal_order, (size_t) (t1.edges.num_rows * sizeof(*rem)));\n\n ret = tsk_table_collection_copy(&t1, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_drop_index(&t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_takeset_indexes(&t2, ins, rem);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(\n tsk_memcmp(t1.indexes.edge_insertion_order, t2.indexes.edge_insertion_order,\n t1.edges.num_rows * sizeof(*ins)),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(t1.indexes.edge_removal_order,\n t2.indexes.edge_removal_order, t1.edges.num_rows * sizeof(*rem)),\n 0);\n\n ret = tsk_table_collection_takeset_indexes(&t2, ins, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_table_collection_takeset_indexes(&t2, NULL, rem);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n tsk_table_collection_free(&t1);\n tsk_table_collection_free(&t2);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_table_collection_delete_older(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t t;\n\n const char *mutations = \"0 2 1 -1\\n\"\n \"0 2 0 0\\n\"\n \"1 0 1 -1\\n\"\n \"2 5 1 -1\\n\";\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n mutations, paper_ex_individuals, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &t, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n\n /* Add some migrations */\n tsk_population_table_add_row(&t.populations, NULL, 0);\n tsk_population_table_add_row(&t.populations, NULL, 0);\n tsk_migration_table_add_row(&t.migrations, 0, 10, 0, 0, 1, 0.05, NULL, 0);\n tsk_migration_table_add_row(&t.migrations, 0, 10, 0, 1, 0, 0.09, NULL, 0);\n tsk_migration_table_add_row(&t.migrations, 0, 10, 0, 0, 1, 0.10, NULL, 0);\n CU_ASSERT_EQUAL(t.migrations.num_rows, 3);\n\n /* Note: trees 1 and 2 are identical now\n *\n 0.09┊ 5 ┊ 5 ┊ 5 ┊\n ┊ ┏┻┓ ┊ ┏━┻┓ ┊ ┏━┻┓ ┊\n 0.07┊ ┃ ┃ ┊ ┃ 4 ┊ ┃ 4 ┊\n ┊ ┃ ┃ ┊ ┃ ┏┻┓ ┊ ┃ ┏┻┓ ┊\n 0.00┊ 0 1 3 2 ┊ 0 1 2 3 ┊ 0 1 2 3 ┊\n 0.00 2.00 7.00 10.00\n */\n\n ret = tsk_table_collection_delete_older(&t, 0.09, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_init(&ts, &t, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 9);\n /* Lost the mutation over 5 */\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 3);\n /* We delete the migration at exactly 0.09. */\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_migrations(&ts), 1);\n\n tsk_table_collection_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nint\nmain(int argc, char **argv)\n{\n CU_TestInfo tests[] = {\n { \"test_node_table\", test_node_table },\n { \"test_node_table_update_row\", test_node_table_update_row },\n { \"test_node_table_keep_rows\", test_node_table_keep_rows },\n { \"test_node_table_takeset\", test_node_table_takeset },\n { \"test_edge_table\", test_edge_table },\n { \"test_edge_table_update_row\", test_edge_table_update_row },\n { \"test_edge_table_update_row_no_metadata\",\n test_edge_table_update_row_no_metadata },\n { \"test_edge_table_keep_rows\", test_edge_table_keep_rows },\n { \"test_edge_table_keep_rows_no_metadata\",\n test_edge_table_keep_rows_no_metadata },\n { \"test_edge_table_takeset\", test_edge_table_takeset },\n { \"test_edge_table_copy_semantics\", test_edge_table_copy_semantics },\n { \"test_edge_table_squash\", test_edge_table_squash },\n { \"test_edge_table_squash_multiple_parents\",\n test_edge_table_squash_multiple_parents },\n { \"test_edge_table_squash_empty\", test_edge_table_squash_empty },\n { \"test_edge_table_squash_single_edge\", test_edge_table_squash_single_edge },\n { \"test_edge_table_squash_bad_intervals\", test_edge_table_squash_bad_intervals },\n { \"test_edge_table_squash_metadata\", test_edge_table_squash_metadata },\n { \"test_site_table\", test_site_table },\n { \"test_site_table_update_row\", test_site_table_update_row },\n { \"test_site_table_keep_rows\", test_site_table_keep_rows },\n { \"test_site_table_takeset\", test_site_table_takeset },\n { \"test_mutation_table\", test_mutation_table },\n { \"test_mutation_table_update_row\", test_mutation_table_update_row },\n { \"test_mutation_table_takeset\", test_mutation_table_takeset },\n { \"test_mutation_table_keep_rows\", test_mutation_table_keep_rows },\n { \"test_mutation_table_keep_rows_parent_references\",\n test_mutation_table_keep_rows_parent_references },\n { \"test_migration_table\", test_migration_table },\n { \"test_migration_table_update_row\", test_migration_table_update_row },\n { \"test_migration_table_keep_rows\", test_migration_table_keep_rows },\n { \"test_migration_table_takeset\", test_migration_table_takeset },\n { \"test_individual_table\", test_individual_table },\n { \"test_individual_table_takeset\", test_individual_table_takeset },\n { \"test_individual_table_update_row\", test_individual_table_update_row },\n { \"test_individual_table_keep_rows\", test_individual_table_keep_rows },\n { \"test_individual_table_keep_rows_parent_references\",\n test_individual_table_keep_rows_parent_references },\n { \"test_population_table\", test_population_table },\n { \"test_population_table_update_row\", test_population_table_update_row },\n { \"test_population_table_keep_rows\", test_population_table_keep_rows },\n { \"test_population_table_takeset\", test_population_table_takeset },\n { \"test_provenance_table\", test_provenance_table },\n { \"test_provenance_table_update_row\", test_provenance_table_update_row },\n { \"test_provenance_table_keep_rows\", test_provenance_table_keep_rows },\n { \"test_provenance_table_takeset\", test_provenance_table_takeset },\n { \"test_table_size_increments\", test_table_size_increments },\n { \"test_table_expansion\", test_table_expansion },\n { \"test_ragged_expansion\", test_ragged_expansion },\n { \"test_table_collection_equals_options\", test_table_collection_equals_options },\n { \"test_table_collection_simplify_errors\",\n test_table_collection_simplify_errors },\n { \"test_table_collection_time_units\", test_table_collection_time_units },\n { \"test_table_collection_reference_sequence\",\n test_table_collection_reference_sequence },\n { \"test_table_collection_has_reference_sequence\",\n test_table_collection_has_reference_sequence },\n { \"test_table_collection_metadata\", test_table_collection_metadata },\n { \"test_reference_sequence_state_machine\",\n test_reference_sequence_state_machine },\n { \"test_reference_sequence_take\", test_reference_sequence_take },\n { \"test_reference_sequence\", test_reference_sequence },\n\n { \"test_simplify_tables_drops_indexes\", test_simplify_tables_drops_indexes },\n { \"test_simplify_empty_tables\", test_simplify_empty_tables },\n { \"test_simplify_metadata\", test_simplify_metadata },\n { \"test_link_ancestors_no_edges\", test_link_ancestors_no_edges },\n { \"test_link_ancestors_input_errors\", test_link_ancestors_input_errors },\n { \"test_link_ancestors_single_tree\", test_link_ancestors_single_tree },\n { \"test_link_ancestors_paper\", test_link_ancestors_paper },\n { \"test_link_ancestors_samples_and_ancestors_overlap\",\n test_link_ancestors_samples_and_ancestors_overlap },\n { \"test_link_ancestors_multiple_to_single_tree\",\n test_link_ancestors_multiple_to_single_tree },\n { \"test_ibd_segments_debug\", test_ibd_segments_debug },\n { \"test_ibd_segments_caterpillar_tree\", test_ibd_segments_caterpillar_tree },\n { \"test_ibd_segments_single_tree\", test_ibd_segments_single_tree },\n { \"test_ibd_segments_single_tree_options\",\n test_ibd_segments_single_tree_options },\n { \"test_ibd_segments_multiple_trees\", test_ibd_segments_multiple_trees },\n { \"test_ibd_segments_empty_result\", test_ibd_segments_empty_result },\n { \"test_ibd_segments_min_span_max_time\", test_ibd_segments_min_span_max_time },\n { \"test_ibd_segments_single_tree_between\",\n test_ibd_segments_single_tree_between },\n { \"test_ibd_segments_samples_are_descendants\",\n test_ibd_segments_samples_are_descendants },\n { \"test_ibd_segments_multiple_ibd_paths\", test_ibd_segments_multiple_ibd_paths },\n { \"test_ibd_segments_odd_topologies\", test_ibd_segments_odd_topologies },\n { \"test_ibd_segments_errors\", test_ibd_segments_errors },\n { \"test_sorter_interface\", test_sorter_interface },\n { \"test_sort_tables_canonical_errors\", test_sort_tables_canonical_errors },\n { \"test_sort_tables_canonical\", test_sort_tables_canonical },\n { \"test_sort_tables_drops_indexes\", test_sort_tables_drops_indexes },\n { \"test_sort_tables_edge_metadata\", test_sort_tables_edge_metadata },\n { \"test_sort_tables_errors\", test_sort_tables_errors },\n { \"test_sort_tables_individuals\", test_sort_tables_individuals },\n { \"test_sort_tables_mutation_times\", test_sort_tables_mutation_times },\n { \"test_sort_tables_mutations\", test_sort_tables_mutations },\n { \"test_sort_tables_migrations\", test_sort_tables_migrations },\n { \"test_sort_tables_no_edge_metadata\", test_sort_tables_no_edge_metadata },\n { \"test_sort_tables_offsets\", test_sort_tables_offsets },\n { \"test_edge_update_invalidates_index\", test_edge_update_invalidates_index },\n { \"test_copy_table_collection\", test_copy_table_collection },\n { \"test_dump_unindexed\", test_dump_unindexed },\n { \"test_dump_load_empty\", test_dump_load_empty },\n { \"test_dump_load_unsorted\", test_dump_load_unsorted },\n { \"test_dump_load_metadata_schema\", test_dump_load_metadata_schema },\n { \"test_dump_fail_no_file\", test_dump_fail_no_file },\n { \"test_load_reindex\", test_load_reindex },\n { \"test_table_overflow\", test_table_overflow },\n { \"test_column_overflow\", test_column_overflow },\n { \"test_table_collection_check_integrity\",\n test_table_collection_check_integrity },\n { \"test_table_collection_check_integrity_no_populations\",\n test_table_collection_check_integrity_no_populations },\n { \"test_table_collection_check_integrity_bad_indexes_example\",\n test_table_collection_check_integrity_bad_indexes_example },\n { \"test_table_collection_check_integrity_bad_indexes\",\n test_table_collection_check_integrity_bad_indexes },\n { \"test_check_integrity_bad_mutation_parent_topology\",\n test_check_integrity_bad_mutation_parent_topology },\n { \"test_table_collection_compute_mutation_parents_tolerates_invalid_input\",\n test_table_collection_compute_mutation_parents_tolerates_invalid_input },\n { \"test_table_collection_compute_mutation_parents_restores_on_error\",\n test_table_collection_compute_mutation_parents_restores_on_error },\n { \"test_table_collection_subset\", test_table_collection_subset },\n { \"test_table_collection_subset_unsorted\",\n test_table_collection_subset_unsorted },\n { \"test_table_collection_subset_errors\", test_table_collection_subset_errors },\n { \"test_table_collection_union\", test_table_collection_union },\n { \"test_table_collection_disjoint_union\", test_table_collection_disjoint_union },\n { \"test_table_collection_union_middle_merge\",\n test_table_collection_union_middle_merge },\n { \"test_table_collection_union_errors\", test_table_collection_union_errors },\n { \"test_table_collection_clear\", test_table_collection_clear },\n { \"test_table_collection_takeset_indexes\",\n test_table_collection_takeset_indexes },\n { \"test_table_collection_delete_older\", test_table_collection_delete_older },\n { NULL, NULL },\n };\n\n return test_main(tests, argc, argv);\n}\n"
},
{
"path": "c/tests/test_trees.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2024 Tskit Developers\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \"testlib.h\"\n#include \n#include \n\n#include \n#include \n\n/*=======================================================\n * Verification utilities.\n *======================================================*/\n\n/* Checks if the specified trees are topologically equivalent, i.e, represent\n * the same tree without checking state specific to seeking.*/\nstatic void\ncheck_trees_equal(tsk_tree_t *self, tsk_tree_t *other)\n{\n tsk_size_t N = self->num_nodes;\n\n CU_ASSERT_FATAL(self->tree_sequence == other->tree_sequence);\n CU_ASSERT_FATAL(self->index == other->index);\n CU_ASSERT_FATAL(self->interval.left == other->interval.left);\n CU_ASSERT_FATAL(self->interval.right == other->interval.right);\n CU_ASSERT_FATAL(self->sites_length == other->sites_length);\n CU_ASSERT_FATAL(self->sites == other->sites);\n CU_ASSERT_FATAL(self->samples == other->samples);\n CU_ASSERT_FATAL(self->num_edges == other->num_edges);\n CU_ASSERT_FATAL(tsk_memcmp(self->parent, other->parent, N * sizeof(tsk_id_t)) == 0);\n CU_ASSERT_FATAL(tsk_tree_equals(self, other));\n}\n\nstatic void\ncheck_trees_identical(tsk_tree_t *self, tsk_tree_t *other)\n{\n tsk_size_t N = self->num_nodes;\n\n check_trees_equal(self, other);\n CU_ASSERT_FATAL(self->left_index == other->left_index);\n CU_ASSERT_FATAL(self->right_index == other->right_index);\n CU_ASSERT_FATAL(self->direction == other->direction);\n\n CU_ASSERT_FATAL(\n tsk_memcmp(self->left_child, other->left_child, N * sizeof(tsk_id_t)) == 0);\n CU_ASSERT_FATAL(\n tsk_memcmp(self->right_child, other->right_child, N * sizeof(tsk_id_t)) == 0);\n CU_ASSERT_FATAL(\n tsk_memcmp(self->left_sib, other->left_sib, N * sizeof(tsk_id_t)) == 0);\n CU_ASSERT_FATAL(\n tsk_memcmp(self->right_sib, other->right_sib, N * sizeof(tsk_id_t)) == 0);\n CU_ASSERT_FATAL(\n tsk_memcmp(self->num_children, other->num_children, N * sizeof(tsk_id_t)) == 0);\n CU_ASSERT_FATAL(tsk_memcmp(self->edge, other->edge, N * sizeof(tsk_id_t)) == 0);\n\n CU_ASSERT_EQUAL_FATAL(self->num_samples == NULL, other->num_samples == NULL)\n CU_ASSERT_EQUAL_FATAL(\n self->num_tracked_samples == NULL, other->num_tracked_samples == NULL)\n if (self->num_samples != NULL) {\n CU_ASSERT_FATAL(tsk_memcmp(self->num_samples, other->num_samples,\n N * sizeof(*self->num_samples))\n == 0);\n CU_ASSERT_FATAL(tsk_memcmp(self->num_tracked_samples, other->num_tracked_samples,\n N * sizeof(*self->num_tracked_samples))\n == 0);\n }\n\n CU_ASSERT_EQUAL_FATAL(self->left_sample == NULL, other->left_sample == NULL)\n CU_ASSERT_EQUAL_FATAL(self->right_sample == NULL, other->left_sample == NULL)\n CU_ASSERT_EQUAL_FATAL(self->next_sample == NULL, other->next_sample == NULL)\n if (self->left_sample != NULL) {\n CU_ASSERT_FATAL(tsk_memcmp(self->left_sample, other->left_sample,\n N * sizeof(*self->left_sample))\n == 0);\n CU_ASSERT_FATAL(tsk_memcmp(self->right_sample, other->right_sample,\n N * sizeof(*self->right_sample))\n == 0);\n CU_ASSERT_FATAL(\n tsk_memcmp(self->next_sample, other->next_sample,\n self->tree_sequence->num_samples * sizeof(*self->next_sample))\n == 0);\n }\n}\n\nstatic void\nverify_compute_mutation_parents(tsk_treeseq_t *ts)\n{\n int ret;\n tsk_size_t size = tsk_treeseq_get_num_mutations(ts) * sizeof(tsk_id_t);\n tsk_id_t *parent = tsk_malloc(size);\n tsk_table_collection_t tables;\n\n CU_ASSERT_FATAL(parent != NULL);\n ret = tsk_treeseq_copy_tables(ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_memcpy(parent, tables.mutations.parent, size);\n /* tsk_table_collection_print_state(&tables, stdout); */\n /* Make sure the tables are actually updated */\n tsk_memset(tables.mutations.parent, 0xff, size);\n\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tsk_memcmp(parent, tables.mutations.parent, size), 0);\n /* printf(\"after\\n\"); */\n /* tsk_table_collection_print_state(&tables, stdout); */\n\n free(parent);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\nverify_compute_mutation_times(tsk_treeseq_t *ts)\n{\n int ret;\n tsk_size_t j;\n tsk_size_t size = tsk_treeseq_get_num_mutations(ts) * sizeof(tsk_id_t);\n tsk_id_t *time = tsk_malloc(size);\n tsk_table_collection_t tables;\n\n CU_ASSERT_FATAL(time != NULL);\n ret = tsk_treeseq_copy_tables(ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_memcpy(time, tables.mutations.time, size);\n /* Time should be set to TSK_UNKNOWN_TIME before computing */\n for (j = 0; j < size; j++) {\n tables.mutations.time[j] = TSK_UNKNOWN_TIME;\n }\n\n ret = tsk_table_collection_compute_mutation_times(&tables, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tsk_memcmp(time, tables.mutations.time, size), 0);\n\n free(time);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\nverify_individual_nodes(tsk_treeseq_t *ts)\n{\n int ret;\n tsk_individual_t individual;\n tsk_id_t k;\n tsk_size_t num_nodes = tsk_treeseq_get_num_nodes(ts);\n tsk_size_t num_individuals = tsk_treeseq_get_num_individuals(ts);\n tsk_size_t j;\n\n for (k = 0; k < (tsk_id_t) num_individuals; k++) {\n ret = tsk_treeseq_get_individual(ts, k, &individual);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < individual.nodes_length; j++) {\n CU_ASSERT_FATAL(individual.nodes[j] < (tsk_id_t) num_nodes);\n CU_ASSERT_EQUAL_FATAL(k, ts->tables->nodes.individual[individual.nodes[j]]);\n }\n }\n}\n\nstatic void\nverify_tree_pos(const tsk_treeseq_t *ts, tsk_size_t num_trees, tsk_id_t *tree_parents)\n{\n int ret;\n const tsk_size_t N = tsk_treeseq_get_num_nodes(ts);\n const tsk_id_t *edges_parent = ts->tables->edges.parent;\n const tsk_id_t *edges_child = ts->tables->edges.child;\n const double *restrict edges_left = ts->tables->edges.left;\n const double *restrict edges_right = ts->tables->edges.right;\n tsk_tree_position_t tree_pos;\n tsk_id_t *known_parent;\n tsk_id_t *parent = tsk_malloc(N * sizeof(*parent));\n tsk_id_t u, index, j, e;\n bool valid;\n\n CU_ASSERT_FATAL(parent != NULL);\n\n ret = tsk_tree_position_init(&tree_pos, ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (u = 0; u < (tsk_id_t) N; u++) {\n parent[u] = TSK_NULL;\n }\n\n for (index = 0; index < (tsk_id_t) num_trees; index++) {\n known_parent = tree_parents + N * (tsk_size_t) index;\n\n valid = tsk_tree_position_next(&tree_pos);\n CU_ASSERT_TRUE(valid);\n CU_ASSERT_EQUAL(index, tree_pos.index);\n\n for (j = tree_pos.out.start; j < tree_pos.out.stop; j++) {\n e = tree_pos.out.order[j];\n parent[edges_child[e]] = TSK_NULL;\n }\n\n for (j = tree_pos.in.start; j < tree_pos.in.stop; j++) {\n e = tree_pos.in.order[j];\n parent[edges_child[e]] = edges_parent[e];\n }\n\n for (u = 0; u < (tsk_id_t) N; u++) {\n CU_ASSERT_EQUAL(parent[u], known_parent[u]);\n }\n }\n\n valid = tsk_tree_position_next(&tree_pos);\n CU_ASSERT_FALSE(valid);\n for (j = tree_pos.out.start; j < tree_pos.out.stop; j++) {\n e = tree_pos.out.order[j];\n parent[edges_child[e]] = TSK_NULL;\n }\n for (u = 0; u < (tsk_id_t) N; u++) {\n CU_ASSERT_EQUAL(parent[u], TSK_NULL);\n }\n\n for (index = (tsk_id_t) num_trees - 1; index >= 0; index--) {\n known_parent = tree_parents + N * (tsk_size_t) index;\n\n valid = tsk_tree_position_prev(&tree_pos);\n CU_ASSERT_TRUE(valid);\n CU_ASSERT_EQUAL(index, tree_pos.index);\n\n for (j = tree_pos.out.start; j > tree_pos.out.stop; j--) {\n e = tree_pos.out.order[j];\n parent[edges_child[e]] = TSK_NULL;\n }\n\n for (j = tree_pos.in.start; j > tree_pos.in.stop; j--) {\n CU_ASSERT_FATAL(j >= 0);\n e = tree_pos.in.order[j];\n parent[edges_child[e]] = edges_parent[e];\n }\n\n for (u = 0; u < (tsk_id_t) N; u++) {\n CU_ASSERT_EQUAL(parent[u], known_parent[u]);\n }\n }\n\n valid = tsk_tree_position_prev(&tree_pos);\n CU_ASSERT_FALSE(valid);\n for (j = tree_pos.out.start; j > tree_pos.out.stop; j--) {\n e = tree_pos.out.order[j];\n parent[edges_child[e]] = TSK_NULL;\n }\n for (u = 0; u < (tsk_id_t) N; u++) {\n CU_ASSERT_EQUAL(parent[u], TSK_NULL);\n }\n\n for (index = 0; index < (tsk_id_t) num_trees; index++) {\n known_parent = tree_parents + N * (tsk_size_t) index;\n ret = tsk_tree_position_init(&tree_pos, ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_tree_position_seek_forward(&tree_pos, index);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(index, tree_pos.index);\n\n for (j = tree_pos.in.start; j != tree_pos.in.stop; j++) {\n e = tree_pos.in.order[j];\n if (edges_left[e] <= tree_pos.interval.left\n && tree_pos.interval.left < edges_right[e]) {\n parent[edges_child[e]] = edges_parent[e];\n }\n }\n for (u = 0; u < (tsk_id_t) N; u++) {\n CU_ASSERT_EQUAL(parent[u], known_parent[u]);\n }\n\n tsk_tree_position_free(&tree_pos);\n for (u = 0; u < (tsk_id_t) N; u++) {\n parent[u] = TSK_NULL;\n }\n }\n\n valid = tsk_tree_position_next(&tree_pos);\n CU_ASSERT_FALSE(valid);\n\n for (index = (tsk_id_t) num_trees - 1; index >= 0; index--) {\n known_parent = tree_parents + N * (tsk_size_t) index;\n ret = tsk_tree_position_init(&tree_pos, ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_tree_position_seek_backward(&tree_pos, index);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(index, tree_pos.index);\n\n for (j = tree_pos.in.start; j != tree_pos.in.stop; j--) {\n e = tree_pos.in.order[j];\n if (edges_right[e] >= tree_pos.interval.right\n && tree_pos.interval.right > edges_left[e]) {\n parent[edges_child[e]] = edges_parent[e];\n }\n }\n\n for (u = 0; u < (tsk_id_t) N; u++) {\n CU_ASSERT_EQUAL(parent[u], known_parent[u]);\n }\n\n for (u = 0; u < (tsk_id_t) N; u++) {\n parent[u] = TSK_NULL;\n }\n tsk_tree_position_free(&tree_pos);\n }\n\n tsk_safe_free(parent);\n}\n\nstatic void\nverify_trees(tsk_treeseq_t *ts, tsk_size_t num_trees, tsk_id_t *parents)\n{\n int ret;\n tsk_id_t u, j, v;\n uint32_t mutation_index, site_index;\n tsk_size_t k, l, tree_sites_length;\n const tsk_site_t *sites = NULL;\n tsk_tree_t tree, skip_tree;\n tsk_size_t num_edges;\n tsk_size_t num_nodes = tsk_treeseq_get_num_nodes(ts);\n tsk_size_t num_sites = tsk_treeseq_get_num_sites(ts);\n tsk_size_t num_mutations = tsk_treeseq_get_num_mutations(ts);\n const double *breakpoints = tsk_treeseq_get_breakpoints(ts);\n\n ret = tsk_tree_init(&tree, ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_init(&skip_tree, ts, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(ts), num_trees);\n\n CU_ASSERT_EQUAL(tree.index, -1);\n site_index = 0;\n mutation_index = 0;\n j = 0;\n for (ret = tsk_tree_first(&tree); ret == TSK_TREE_OK; ret = tsk_tree_next(&tree)) {\n CU_ASSERT_EQUAL(j, (tsk_id_t) tree.index);\n tsk_tree_print_state(&tree, _devnull);\n /* tsk_tree_print_state(&tree, stdout); */\n CU_ASSERT_EQUAL(tree.interval.left, breakpoints[j]);\n num_edges = 0;\n for (u = 0; u < (tsk_id_t) num_nodes; u++) {\n ret = tsk_tree_get_parent(&tree, u, &v);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(v, parents[j * (tsk_id_t) num_nodes + u]);\n if (v != TSK_NULL) {\n num_edges++;\n }\n }\n CU_ASSERT_EQUAL(num_edges, tree.num_edges);\n ret = tsk_tree_get_sites(&tree, &sites, &tree_sites_length);\n CU_ASSERT_EQUAL(ret, 0);\n for (k = 0; k < tree_sites_length; k++) {\n CU_ASSERT_EQUAL(sites[k].id, (tsk_id_t) site_index);\n for (l = 0; l < sites[k].mutations_length; l++) {\n CU_ASSERT_EQUAL(sites[k].mutations[l].id, (tsk_id_t) mutation_index);\n CU_ASSERT_EQUAL(sites[k].mutations[l].site, (tsk_id_t) site_index);\n mutation_index++;\n }\n site_index++;\n }\n /* Check the skip tree */\n ret = tsk_tree_first(&skip_tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n ret = tsk_tree_seek(&skip_tree, breakpoints[j], TSK_SEEK_SKIP);\n CU_ASSERT_EQUAL(ret, 0);\n /* Calling print_state here also verifies the integrity of the tree */\n tsk_tree_print_state(&skip_tree, _devnull);\n check_trees_equal(&tree, &skip_tree);\n ret = tsk_tree_last(&skip_tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n ret = tsk_tree_seek(&skip_tree, breakpoints[j], TSK_SEEK_SKIP);\n CU_ASSERT_EQUAL(ret, 0);\n tsk_tree_print_state(&skip_tree, _devnull);\n check_trees_equal(&tree, &skip_tree);\n\n j++;\n }\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(site_index, num_sites);\n CU_ASSERT_EQUAL(mutation_index, num_mutations);\n CU_ASSERT_EQUAL(tree.index, -1);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(ts), breakpoints[j]);\n\n tsk_tree_free(&tree);\n tsk_tree_free(&skip_tree);\n\n verify_tree_pos(ts, num_trees, parents);\n}\n\nstatic tsk_tree_t *\nget_tree_list(tsk_treeseq_t *ts)\n{\n int ret;\n tsk_tree_t t, *trees;\n tsk_size_t num_trees;\n\n num_trees = tsk_treeseq_get_num_trees(ts);\n ret = tsk_tree_init(&t, ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n trees = tsk_malloc(num_trees * sizeof(tsk_tree_t));\n CU_ASSERT_FATAL(trees != NULL);\n for (ret = tsk_tree_first(&t); ret == TSK_TREE_OK; ret = tsk_tree_next(&t)) {\n CU_ASSERT_FATAL(t.index < (tsk_id_t) num_trees);\n ret = tsk_tree_copy(&t, &trees[t.index], 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n check_trees_equal(&trees[t.index], &t);\n /* Make sure the left and right coordinates are also OK */\n CU_ASSERT_EQUAL(trees[t.index].interval.left, t.interval.left);\n CU_ASSERT_EQUAL(trees[t.index].interval.right, t.interval.right);\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_free(&t);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n return trees;\n}\n\nstatic void\nverify_tree_next_prev(tsk_treeseq_t *ts)\n{\n int ret;\n tsk_tree_t *trees, t;\n tsk_id_t j;\n tsk_id_t num_trees = (tsk_id_t) tsk_treeseq_get_num_trees(ts);\n\n trees = get_tree_list(ts);\n ret = tsk_tree_init(&t, ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Single forward pass */\n j = 0;\n for (ret = tsk_tree_first(&t); ret == TSK_TREE_OK; ret = tsk_tree_next(&t)) {\n CU_ASSERT_EQUAL_FATAL(j, t.index);\n check_trees_equal(&t, &trees[t.index]);\n j++;\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(j, num_trees);\n\n /* Single reverse pass */\n j = num_trees;\n for (ret = tsk_tree_last(&t); ret == TSK_TREE_OK; ret = tsk_tree_prev(&t)) {\n CU_ASSERT_EQUAL_FATAL(j - 1, t.index);\n check_trees_equal(&t, &trees[t.index]);\n j--;\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(j, 0);\n\n /* Full forward, then reverse */\n j = 0;\n for (ret = tsk_tree_first(&t); ret == TSK_TREE_OK; ret = tsk_tree_next(&t)) {\n CU_ASSERT_EQUAL_FATAL(j, t.index);\n check_trees_equal(&t, &trees[t.index]);\n j++;\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(j, num_trees);\n while ((ret = tsk_tree_prev(&t)) == TSK_TREE_OK) {\n CU_ASSERT_EQUAL_FATAL(j - 1, t.index);\n check_trees_equal(&t, &trees[t.index]);\n j--;\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(j, 0);\n CU_ASSERT_EQUAL_FATAL(t.index, -1);\n\n /* Full reverse then forward */\n j = num_trees;\n for (ret = tsk_tree_last(&t); ret == TSK_TREE_OK; ret = tsk_tree_prev(&t)) {\n CU_ASSERT_EQUAL_FATAL(j - 1, t.index);\n check_trees_equal(&t, &trees[t.index]);\n j--;\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(j, 0);\n while ((ret = tsk_tree_next(&t)) == TSK_TREE_OK) {\n CU_ASSERT_EQUAL_FATAL(j, t.index);\n check_trees_equal(&t, &trees[t.index]);\n j++;\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(j, num_trees);\n CU_ASSERT_EQUAL_FATAL(t.index, -1);\n\n /* Do a zigzagging traversal */\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n for (j = 1; j < TSK_MIN(10, num_trees / 2); j++) {\n while (t.index < num_trees - j) {\n ret = tsk_tree_next(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n }\n CU_ASSERT_EQUAL_FATAL(t.index, num_trees - j);\n check_trees_equal(&t, &trees[t.index]);\n while (t.index > j) {\n ret = tsk_tree_prev(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n }\n CU_ASSERT_EQUAL_FATAL(t.index, j);\n check_trees_equal(&t, &trees[t.index]);\n }\n\n ret = tsk_tree_clear(&t);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Calling next() on a cleared tree should be the same as first() */\n j = 0;\n while ((ret = tsk_tree_next(&t)) == TSK_TREE_OK) {\n CU_ASSERT_EQUAL_FATAL(j, t.index);\n check_trees_equal(&t, &trees[t.index]);\n j++;\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(j, num_trees);\n\n ret = tsk_tree_free(&t);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_init(&t, ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* Calling prev() on an uninitialised tree should be the same as last() */\n\n j = num_trees;\n while ((ret = tsk_tree_prev(&t)) == TSK_TREE_OK) {\n CU_ASSERT_EQUAL_FATAL(j - 1, t.index);\n check_trees_equal(&t, &trees[t.index]);\n j--;\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(j, 0);\n\n /* Free the trees. */\n ret = tsk_tree_free(&t);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < (tsk_id_t) tsk_treeseq_get_num_trees(ts); j++) {\n tsk_tree_free(&trees[j]);\n }\n free(trees);\n}\n\nstatic void\nverify_edge_array_single_tree(\n tsk_tree_t *tree, tsk_edge_table_t *edge_table, tsk_size_t num_nodes)\n{\n int ret;\n tsk_id_t c, edge_id;\n tsk_edge_t edge;\n tsk_size_t count_edges = 0;\n\n for (c = 0; c <= (tsk_id_t) num_nodes; c++) {\n edge_id = tree->edge[c];\n if (edge_id == TSK_NULL) {\n /*c is either (virtual) root,\n or is not associated with an edge along this tree */\n CU_ASSERT_EQUAL(tree->parent[c], TSK_NULL);\n } else {\n ret = tsk_edge_table_get_row(edge_table, edge_id, &edge);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(edge.id, edge_id);\n CU_ASSERT_EQUAL(edge.parent, tree->parent[c]);\n CU_ASSERT_EQUAL(edge.child, c);\n count_edges++;\n }\n }\n\n CU_ASSERT_EQUAL(count_edges, tree->num_edges);\n}\n\nstatic void\nverify_edge_array_trees(tsk_treeseq_t *ts)\n{\n int ret;\n tsk_tree_t t;\n tsk_edge_table_t edge_table;\n tsk_size_t num_nodes;\n tsk_id_t c;\n\n num_nodes = tsk_treeseq_get_num_nodes(ts);\n\n edge_table = ts->tables->edges;\n ret = tsk_tree_init(&t, ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* verify initialized edge array */\n for (c = 0; c <= (tsk_id_t) num_nodes; c++) {\n CU_ASSERT_EQUAL(t.edge[c], TSK_NULL)\n }\n /* verify edge array for each tree in treesequence */\n for (ret = tsk_tree_first(&t); ret == TSK_TREE_OK; ret = tsk_tree_next(&t)) {\n verify_edge_array_single_tree(&t, &edge_table, num_nodes);\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n /* verify cleared edge array */\n for (c = 0; c <= (tsk_id_t) num_nodes; c++) {\n CU_ASSERT_EQUAL(t.edge[c], TSK_NULL)\n }\n\n tsk_tree_free(&t);\n}\n\n/* When we keep all sites in simplify, the genotypes for the subset of the\n * samples should be the same as the original */\nstatic void\nverify_simplify_genotypes(tsk_treeseq_t *ts, tsk_treeseq_t *subset,\n const tsk_id_t *samples, tsk_size_t num_samples)\n{\n int ret;\n tsk_size_t m = tsk_treeseq_get_num_sites(ts);\n tsk_vargen_t vargen, subset_vargen;\n tsk_variant_t *variant, *subset_variant;\n tsk_size_t j, k;\n int32_t a1, a2;\n const tsk_id_t *sample_index_map;\n\n sample_index_map = tsk_treeseq_get_sample_index_map(ts);\n\n /* tsk_treeseq_print_state(ts, stdout); */\n /* tsk_treeseq_print_state(subset, stdout); */\n\n ret = tsk_vargen_init(&vargen, ts, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_vargen_init(\n &subset_vargen, subset, NULL, 0, NULL, TSK_ISOLATED_NOT_MISSING);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(m, tsk_treeseq_get_num_sites(subset));\n\n for (j = 0; j < m; j++) {\n ret = tsk_vargen_next(&vargen, &variant);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n ret = tsk_vargen_next(&subset_vargen, &subset_variant);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(variant->site.id, (tsk_id_t) j)\n CU_ASSERT_EQUAL(subset_variant->site.id, (tsk_id_t) j)\n CU_ASSERT_EQUAL(variant->site.position, subset_variant->site.position);\n for (k = 0; k < num_samples; k++) {\n CU_ASSERT_FATAL(sample_index_map[samples[k]] < (tsk_id_t) ts->num_samples);\n a1 = variant->genotypes[sample_index_map[samples[k]]];\n a2 = subset_variant->genotypes[k];\n /* printf(\"a1 = %d, a2 = %d\\n\", a1, a2); */\n /* printf(\"k = %d original node = %d \" */\n /* \"original_index = %d a1=%.*s a2=%.*s\\n\", */\n /* (int) k, samples[k], sample_index_map[samples[k]], */\n /* variant->allele_lengths[a1], variant->alleles[a1], */\n /* subset_variant->allele_lengths[a2], subset_variant->alleles[a2]);\n */\n CU_ASSERT_FATAL(a1 < (int) variant->num_alleles);\n CU_ASSERT_FATAL(a2 < (int) subset_variant->num_alleles);\n CU_ASSERT_EQUAL_FATAL(\n variant->allele_lengths[a1], subset_variant->allele_lengths[a2]);\n CU_ASSERT_NSTRING_EQUAL_FATAL(variant->alleles[a1],\n subset_variant->alleles[a2], variant->allele_lengths[a1]);\n }\n }\n tsk_vargen_free(&vargen);\n tsk_vargen_free(&subset_vargen);\n}\n\nstatic void\nverify_simplify_properties(tsk_treeseq_t *ts, tsk_treeseq_t *subset,\n const tsk_id_t *samples, tsk_size_t num_samples, tsk_id_t *node_map)\n{\n int ret;\n tsk_node_t n1, n2;\n tsk_tree_t full_tree, subset_tree;\n const tsk_site_t *tree_sites;\n tsk_size_t tree_sites_length;\n uint32_t j, k;\n tsk_id_t u, mrca1, mrca2;\n tsk_size_t total_sites;\n\n CU_ASSERT_EQUAL(\n tsk_treeseq_get_sequence_length(ts), tsk_treeseq_get_sequence_length(subset));\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(subset), num_samples);\n CU_ASSERT(tsk_treeseq_get_num_nodes(ts) >= tsk_treeseq_get_num_nodes(subset));\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(subset), num_samples);\n\n /* Check the sample properties */\n for (j = 0; j < num_samples; j++) {\n ret = tsk_treeseq_get_node(ts, samples[j], &n1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(node_map[samples[j]], (tsk_id_t) j);\n ret = tsk_treeseq_get_node(subset, node_map[samples[j]], &n2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n1.population, n2.population);\n CU_ASSERT_EQUAL_FATAL(n1.time, n2.time);\n CU_ASSERT_EQUAL_FATAL(n1.flags, n2.flags);\n CU_ASSERT_EQUAL_FATAL(n1.metadata_length, n2.metadata_length);\n CU_ASSERT_NSTRING_EQUAL(n1.metadata, n2.metadata, n2.metadata_length);\n }\n /* Check that node mappings are correct */\n for (j = 0; j < tsk_treeseq_get_num_nodes(ts); j++) {\n ret = tsk_treeseq_get_node(ts, (tsk_id_t) j, &n1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n if (node_map[j] != TSK_NULL) {\n ret = tsk_treeseq_get_node(subset, node_map[j], &n2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n1.population, n2.population);\n CU_ASSERT_EQUAL_FATAL(n1.time, n2.time);\n CU_ASSERT_EQUAL_FATAL(n1.flags, n2.flags);\n CU_ASSERT_EQUAL_FATAL(n1.metadata_length, n2.metadata_length);\n CU_ASSERT_NSTRING_EQUAL(n1.metadata, n2.metadata, n2.metadata_length);\n }\n }\n if (num_samples == 0) {\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_edges(subset), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(subset), 0);\n } else if (num_samples == 1) {\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_edges(subset), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(subset), 1);\n }\n /* Check the pairwise MRCAs */\n ret = tsk_tree_init(&full_tree, ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_init(&subset_tree, subset, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&full_tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n ret = tsk_tree_first(&subset_tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n\n total_sites = 0;\n while (1) {\n while (full_tree.interval.right <= subset_tree.interval.right) {\n for (j = 0; j < num_samples; j++) {\n for (k = j + 1; k < num_samples; k++) {\n ret = tsk_tree_get_mrca(&full_tree, samples[j], samples[k], &mrca1);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_get_mrca(&subset_tree, node_map[samples[j]],\n node_map[samples[k]], &mrca2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n if (mrca1 == TSK_NULL) {\n CU_ASSERT_EQUAL_FATAL(mrca2, TSK_NULL);\n } else {\n CU_ASSERT_EQUAL(node_map[mrca1], mrca2);\n }\n }\n }\n ret = tsk_tree_next(&full_tree);\n CU_ASSERT_FATAL(ret >= 0);\n if (ret != 1) {\n break;\n }\n }\n /* Check the sites in this tree */\n ret = tsk_tree_get_sites(&subset_tree, &tree_sites, &tree_sites_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = 0; j < tree_sites_length; j++) {\n CU_ASSERT(subset_tree.interval.left <= tree_sites[j].position);\n CU_ASSERT(tree_sites[j].position < subset_tree.interval.right);\n for (k = 0; k < tree_sites[j].mutations_length; k++) {\n ret = tsk_tree_get_parent(\n &subset_tree, tree_sites[j].mutations[k].node, &u);\n CU_ASSERT_EQUAL(ret, 0);\n }\n total_sites++;\n }\n ret = tsk_tree_next(&subset_tree);\n if (ret != 1) {\n break;\n }\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(subset), total_sites);\n\n tsk_tree_free(&subset_tree);\n tsk_tree_free(&full_tree);\n}\n\nstatic void\nverify_simplify(tsk_treeseq_t *ts)\n{\n int ret;\n tsk_size_t n = tsk_treeseq_get_num_samples(ts);\n tsk_size_t num_samples[] = { 0, 1, 2, 3, n / 2, n - 1, n };\n tsk_size_t j;\n const tsk_id_t *sample;\n tsk_id_t *node_map = tsk_malloc(tsk_treeseq_get_num_nodes(ts) * sizeof(tsk_id_t));\n tsk_treeseq_t subset;\n tsk_flags_t options = TSK_SIMPLIFY_FILTER_SITES;\n\n CU_ASSERT_FATAL(node_map != NULL);\n sample = tsk_treeseq_get_samples(ts);\n if (tsk_treeseq_get_num_migrations(ts) > 0) {\n ret = tsk_treeseq_simplify(ts, sample, 2, 0, &subset, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SIMPLIFY_MIGRATIONS_NOT_SUPPORTED);\n /* Exiting early here because simplify isn't supported with migrations. */\n goto out;\n }\n\n for (j = 0; j < sizeof(num_samples) / sizeof(*num_samples); j++) {\n if (num_samples[j] <= n) {\n ret = tsk_treeseq_simplify(\n ts, sample, num_samples[j], options, &subset, node_map);\n /* printf(\"ret = %s\\n\", tsk_strerror(ret)); */\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n verify_simplify_properties(ts, &subset, sample, num_samples[j], node_map);\n tsk_treeseq_free(&subset);\n\n /* Keep all sites */\n ret = tsk_treeseq_simplify(ts, sample, num_samples[j], 0, &subset, node_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n verify_simplify_properties(ts, &subset, sample, num_samples[j], node_map);\n verify_simplify_genotypes(ts, &subset, sample, num_samples[j]);\n tsk_treeseq_free(&subset);\n }\n }\nout:\n free(node_map);\n}\n\ntypedef struct {\n tsk_id_t tree_index;\n tsk_id_t node;\n tsk_size_t count;\n} sample_count_test_t;\n\nstatic void\nverify_sample_counts(tsk_treeseq_t *ts, tsk_size_t num_tests, sample_count_test_t *tests,\n tsk_flags_t seek_options)\n{\n int ret;\n tsk_size_t j, num_samples, n, k;\n tsk_id_t stop, sample_index;\n tsk_tree_t tree;\n const tsk_id_t *samples;\n\n n = tsk_treeseq_get_num_samples(ts);\n samples = tsk_treeseq_get_samples(ts);\n\n /* First run with the TSK_NO_SAMPLE_COUNTS feature */\n\n ret = tsk_tree_init(&tree, ts, TSK_NO_SAMPLE_COUNTS);\n CU_ASSERT_EQUAL(ret, 0);\n for (j = 0; j < num_tests; j++) {\n ret = tsk_tree_seek_index(&tree, tests[j].tree_index, seek_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_get_num_samples(&tree, tests[j].node, &num_samples);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tests[j].count, num_samples);\n /* all operations depending on tracked samples should fail. */\n ret = tsk_tree_get_num_tracked_samples(&tree, 0, &num_samples);\n CU_ASSERT_EQUAL(ret, TSK_ERR_UNSUPPORTED_OPERATION);\n /* The root should be NULL */\n CU_ASSERT_EQUAL(tsk_tree_get_left_root(&tree), TSK_NULL);\n }\n tsk_tree_free(&tree);\n\n /* Now run with TSK_SAMPLE_COUNTS but with no samples tracked. */\n ret = tsk_tree_init(&tree, ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n for (j = 0; j < num_tests; j++) {\n ret = tsk_tree_seek_index(&tree, tests[j].tree_index, seek_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_get_num_samples(&tree, tests[j].node, &num_samples);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tests[j].count, num_samples);\n /* all operations depending on tracked samples should fail. */\n ret = tsk_tree_get_num_tracked_samples(&tree, 0, &num_samples);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(num_samples, 0);\n /* The root should not be NULL */\n CU_ASSERT_NOT_EQUAL(tree.virtual_root, TSK_NULL);\n }\n tsk_tree_free(&tree);\n\n /* Run with TSK_SAMPLE_LISTS and TSK_NO_SAMPLE_COUNTS */\n ret = tsk_tree_init(&tree, ts, TSK_SAMPLE_LISTS | TSK_NO_SAMPLE_COUNTS);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n for (j = 0; j < num_tests; j++) {\n ret = tsk_tree_seek_index(&tree, tests[j].tree_index, seek_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_get_num_samples(&tree, tests[j].node, &num_samples);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tests[j].count, num_samples);\n /* all operations depending on tracked samples should fail. */\n ret = tsk_tree_get_num_tracked_samples(&tree, 0, &num_samples);\n CU_ASSERT_EQUAL(ret, TSK_ERR_UNSUPPORTED_OPERATION);\n\n sample_index = tree.left_sample[tests[j].node];\n k = 0;\n if (sample_index != TSK_NULL) {\n stop = tree.right_sample[tests[j].node];\n while (true) {\n k++;\n CU_ASSERT_FATAL(k <= tests[j].count);\n if (sample_index == stop) {\n break;\n }\n sample_index = tree.next_sample[sample_index];\n }\n }\n CU_ASSERT_EQUAL(tests[j].count, k);\n }\n tsk_tree_free(&tree);\n\n /* Now use TSK_SAMPLE_LISTS */\n ret = tsk_tree_init(&tree, ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_set_tracked_samples(&tree, n, samples);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n for (j = 0; j < num_tests; j++) {\n ret = tsk_tree_seek_index(&tree, tests[j].tree_index, seek_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_get_num_samples(&tree, tests[j].node, &num_samples);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tests[j].count, num_samples);\n\n /* We're tracking all samples, so the count should be the same */\n ret = tsk_tree_get_num_tracked_samples(&tree, tests[j].node, &num_samples);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tests[j].count, num_samples);\n\n sample_index = tree.left_sample[tests[j].node];\n k = 0;\n if (sample_index != TSK_NULL) {\n stop = tree.right_sample[tests[j].node];\n while (true) {\n k++;\n if (sample_index == stop) {\n break;\n }\n sample_index = tree.next_sample[sample_index];\n }\n }\n CU_ASSERT_EQUAL(tests[j].count, k);\n }\n tsk_tree_free(&tree);\n}\n\nstatic void\nverify_sample_sets_for_tree(tsk_tree_t *tree)\n{\n int ret, stack_top, j;\n tsk_id_t u, v;\n tsk_size_t tmp, n, num_nodes, num_samples;\n tsk_id_t *stack, *samples;\n const tsk_treeseq_t *ts = tree->tree_sequence;\n tsk_id_t *sample_index_map = ts->sample_index_map;\n const tsk_id_t *list_left = tree->left_sample;\n const tsk_id_t *list_right = tree->right_sample;\n const tsk_id_t *list_next = tree->next_sample;\n tsk_id_t stop, sample_index;\n\n n = tsk_treeseq_get_num_samples(ts);\n num_nodes = tsk_treeseq_get_num_nodes(ts);\n stack = tsk_malloc(n * sizeof(tsk_id_t));\n samples = tsk_malloc(n * sizeof(tsk_id_t));\n CU_ASSERT_FATAL(stack != NULL);\n CU_ASSERT_FATAL(samples != NULL);\n for (u = 0; u < (tsk_id_t) num_nodes; u++) {\n if (tree->left_child[u] == TSK_NULL && !tsk_treeseq_is_sample(ts, u)) {\n CU_ASSERT_EQUAL(list_left[u], TSK_NULL);\n CU_ASSERT_EQUAL(list_right[u], TSK_NULL);\n } else {\n stack_top = 0;\n num_samples = 0;\n stack[stack_top] = u;\n while (stack_top >= 0) {\n v = stack[stack_top];\n stack_top--;\n if (tsk_treeseq_is_sample(ts, v)) {\n samples[num_samples] = v;\n num_samples++;\n }\n for (v = tree->right_child[v]; v != TSK_NULL; v = tree->left_sib[v]) {\n stack_top++;\n stack[stack_top] = v;\n }\n }\n ret = tsk_tree_get_num_samples(tree, u, &tmp);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(num_samples, tmp);\n\n j = 0;\n sample_index = list_left[u];\n if (sample_index != TSK_NULL) {\n stop = list_right[u];\n while (true) {\n CU_ASSERT_TRUE_FATAL(j < (tsk_id_t) n);\n CU_ASSERT_EQUAL_FATAL(sample_index, sample_index_map[samples[j]]);\n j++;\n if (sample_index == stop) {\n break;\n }\n sample_index = list_next[sample_index];\n }\n }\n CU_ASSERT_EQUAL_FATAL(j, (int) num_samples);\n }\n }\n free(stack);\n free(samples);\n}\n\nstatic void\nverify_sample_sets(tsk_treeseq_t *ts)\n{\n int ret;\n tsk_tree_t t;\n tsk_id_t j;\n\n ret = tsk_tree_init(&t, ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL(ret, 0);\n\n for (ret = tsk_tree_first(&t); ret == TSK_TREE_OK; ret = tsk_tree_next(&t)) {\n verify_sample_sets_for_tree(&t);\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (ret = tsk_tree_last(&t); ret == TSK_TREE_OK; ret = tsk_tree_prev(&t)) {\n verify_sample_sets_for_tree(&t);\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = 0; j < (tsk_id_t) tsk_treeseq_get_num_trees(ts); j++) {\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n ret = tsk_tree_seek_index(&t, j, TSK_SEEK_SKIP);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n verify_sample_sets_for_tree(&t);\n\n ret = tsk_tree_last(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n ret = tsk_tree_seek_index(&t, j, TSK_SEEK_SKIP);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n verify_sample_sets_for_tree(&t);\n }\n\n tsk_tree_free(&t);\n}\n\nstatic void\nverify_empty_tree_sequence(tsk_treeseq_t *ts, double sequence_length)\n{\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_edges(ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_migrations(ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(ts), sequence_length);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(ts), 1);\n}\n\n/*=======================================================\n * Simplest test cases.\n *======================================================*/\n\nstatic void\ntest_simplest_discrete_genome(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\";\n const char *edges = \"0 1 2 0,1\\n\";\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_id_t ret_id;\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n CU_ASSERT_TRUE(tsk_treeseq_get_discrete_genome(&ts));\n\n ret = tsk_table_collection_copy(ts.tables, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n\n tables.sequence_length = 1.001;\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_treeseq_get_discrete_genome(&ts));\n tsk_treeseq_free(&ts);\n tables.sequence_length = 1;\n\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_treeseq_get_discrete_genome(&ts));\n tsk_treeseq_free(&ts);\n\n tables.edges.right[0] = 0.999;\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_treeseq_get_discrete_genome(&ts));\n tsk_treeseq_free(&ts);\n tables.edges.right[0] = 1.0;\n\n tables.edges.left[0] = 0.999;\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_treeseq_get_discrete_genome(&ts));\n tsk_treeseq_free(&ts);\n tables.edges.left[0] = 0;\n\n ret_id = tsk_site_table_add_row(&tables.sites, 0, \"A\", 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_treeseq_get_discrete_genome(&ts));\n tsk_treeseq_free(&ts);\n\n tables.sites.position[0] = 0.001;\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_treeseq_get_discrete_genome(&ts));\n tsk_treeseq_free(&ts);\n tables.sites.position[0] = 0;\n\n /* Need another population for a migration */\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n\n ret_id\n = tsk_migration_table_add_row(&tables.migrations, 0, 1, 0, 0, 1, 1.0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_treeseq_get_discrete_genome(&ts));\n tsk_treeseq_free(&ts);\n\n tables.migrations.left[0] = 0.001;\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_treeseq_get_discrete_genome(&ts));\n tsk_treeseq_free(&ts);\n tables.migrations.left[0] = 0;\n\n tables.migrations.right[0] = 0.999;\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_treeseq_get_discrete_genome(&ts));\n tsk_treeseq_free(&ts);\n tables.migrations.right[0] = 1;\n\n /* An empty tree sequence is has a discrete genome. */\n tsk_table_collection_clear(&tables, 0);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_treeseq_get_discrete_genome(&ts));\n tsk_treeseq_free(&ts);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_discrete_time(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 0 0\\n\"\n \"0 0 0\";\n const char *edges = \"0 1 2 0,1,3,4\\n\";\n const char *sites = \"0.1 0\\n\"\n \"0.2 0\\n\"\n \"0.3 0\\n\"\n \"0.4 0\\n\";\n const char *mutations = \"0 0 1\\n\"\n \"1 1 1\\n\"\n \"2 3 1\\n\"\n \"3 4 1\";\n const char *migrations = \"0 1 0 0 1 1\";\n\n tsk_treeseq_from_text(\n &ts, 1, nodes, edges, migrations, sites, mutations, NULL, NULL, 0);\n CU_ASSERT_TRUE(tsk_treeseq_get_discrete_time(&ts));\n\n ret = tsk_table_collection_copy(ts.tables, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_treeseq_get_discrete_time(&ts));\n tsk_treeseq_free(&ts);\n\n tables.nodes.time[0] = 0.0001;\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_treeseq_get_discrete_time(&ts));\n tsk_treeseq_free(&ts);\n tables.nodes.time[0] = 0;\n\n tables.mutations.time[0] = 0.001;\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_treeseq_get_discrete_time(&ts));\n tsk_treeseq_free(&ts);\n tables.mutations.time[0] = 0;\n\n tables.migrations.time[0] = 0.001;\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_treeseq_get_discrete_time(&ts));\n tsk_treeseq_free(&ts);\n tables.migrations.time[0] = 0;\n\n tables.mutations.time[0] = TSK_UNKNOWN_TIME;\n tables.mutations.time[1] = TSK_UNKNOWN_TIME;\n tables.mutations.time[2] = TSK_UNKNOWN_TIME;\n tables.mutations.time[3] = TSK_UNKNOWN_TIME;\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_treeseq_get_discrete_time(&ts));\n tsk_treeseq_free(&ts);\n\n /* An empty tree sequence is has a discrete time. */\n tsk_table_collection_clear(&tables, 0);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_treeseq_get_discrete_time(&ts));\n tsk_treeseq_free(&ts);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_min_time(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n\n const char *nodes = \"1 0.1 0 -1\\n\"\n \"1 0.1 0 -1\\n\"\n \"1 0.1 0 -1\\n\"\n \"0 1 0 -1\\n\"\n \"0 2 0 -1\\n\";\n const char *edges = \"0 2 3 0,1\\n\"\n \"0 2 4 2,3\\n\";\n const char *sites = \"0 0\\n\"\n \"1 0\\n\";\n const char *mutations = \"0 2 1 -1 0.5\\n\"\n \"1 3 1 -1 1.5\\n\";\n\n tsk_treeseq_from_text(&ts, 2, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n CU_ASSERT_DOUBLE_EQUAL(tsk_treeseq_get_min_time(&ts), 0.1, 1E-6);\n\n ret = tsk_table_collection_copy(ts.tables, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL(tsk_treeseq_get_min_time(&ts), 0.1, 1E-6);\n tsk_treeseq_free(&ts);\n\n /* Setting mutation times to unknown should have no effect on min time. */\n tables.mutations.time[0] = TSK_UNKNOWN_TIME;\n tables.mutations.time[1] = TSK_UNKNOWN_TIME;\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL(tsk_treeseq_get_min_time(&ts), 0.1, 1E-6);\n tsk_treeseq_free(&ts);\n tables.mutations.time[0] = 0.5;\n tables.mutations.time[1] = 1.5;\n\n /* An empty tree sequence has infinity min time. */\n tsk_table_collection_clear(&tables, 0);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_min_time(&ts), INFINITY);\n tsk_treeseq_free(&ts);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_max_time(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n\n const char *nodes = \"1 0.1 0 -1\\n\"\n \"1 0.1 0 -1\\n\"\n \"1 0.1 0 -1\\n\"\n \"0 1 0 -1\\n\"\n \"0 2 0 -1\\n\";\n const char *edges = \"0 2 3 0,1\\n\"\n \"0 2 4 2,3\\n\";\n const char *sites = \"0 0\\n\"\n \"1 0\\n\";\n const char *mutations = \"0 2 1 -1 0.5\\n\"\n \"1 3 1 -1 1.5\\n\";\n\n tsk_treeseq_from_text(&ts, 2, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n CU_ASSERT_DOUBLE_EQUAL(tsk_treeseq_get_max_time(&ts), 2.0, 1E-6);\n\n ret = tsk_table_collection_copy(ts.tables, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL(tsk_treeseq_get_max_time(&ts), 2.0, 1E-6);\n tsk_treeseq_free(&ts);\n\n /* Setting mutation times to unknown should have no effect on max time. */\n tables.mutations.time[0] = TSK_UNKNOWN_TIME;\n tables.mutations.time[1] = TSK_UNKNOWN_TIME;\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL(tsk_treeseq_get_max_time(&ts), 2.0, 1E-6);\n tsk_treeseq_free(&ts);\n tables.mutations.time[0] = 0.5;\n tables.mutations.time[1] = 1.5;\n\n /* An empty tree sequence has negative infinity max time. */\n tsk_table_collection_clear(&tables, 0);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_max_time(&ts), -INFINITY);\n tsk_treeseq_free(&ts);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_records(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\";\n const char *edges = \"0 1 2 0,1\\n\";\n tsk_treeseq_t ts, simplified;\n tsk_id_t sample_ids[] = { 0, 1 };\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n\n ret = tsk_treeseq_simplify(&ts, sample_ids, 2, 0, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n ret = tsk_treeseq_simplify(&ts, sample_ids, 2,\n TSK_SIMPLIFY_KEEP_UNARY | TSK_SIMPLIFY_KEEP_UNARY_IN_INDIVIDUALS, &simplified,\n NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_KEEP_UNARY_MUTUALLY_EXCLUSIVE);\n tsk_treeseq_free(&simplified);\n\n ret = tsk_treeseq_simplify(\n &ts, sample_ids, 2, TSK_SIMPLIFY_KEEP_UNARY, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n ret = tsk_treeseq_simplify(\n &ts, sample_ids, 2, TSK_SIMPLIFY_KEEP_UNARY_IN_INDIVIDUALS, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_nonbinary_records(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\";\n const char *edges = \"0 1 4 0,1,2,3\\n\";\n tsk_treeseq_t ts, simplified;\n tsk_tree_t t;\n tsk_id_t sample_ids[] = { 0, 1, 2, 3 };\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 4);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 5);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL(t.num_children[4], 4);\n CU_ASSERT_EQUAL(tsk_tree_get_num_roots(&t), 1);\n tsk_tree_free(&t);\n\n ret = tsk_treeseq_simplify(&ts, sample_ids, 4, 0, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n ret = tsk_treeseq_simplify(\n &ts, sample_ids, 4, TSK_SIMPLIFY_KEEP_UNARY, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n ret = tsk_treeseq_simplify(\n &ts, sample_ids, 4, TSK_SIMPLIFY_KEEP_UNARY_IN_INDIVIDUALS, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_unary_records(void)\n{\n int ret;\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 1 0\\n\"\n \"0 2 0\";\n const char *edges = \"0 1 2 0\\n\"\n \"0 1 3 1\\n\"\n \"0 1 4 2,3\\n\";\n tsk_treeseq_t ts, simplified, simplified_other;\n tsk_tree_t t;\n tsk_id_t sample_ids[] = { 0, 1 };\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 5);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_populations(&ts), 1);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL(t.num_children[2], 1);\n CU_ASSERT_EQUAL(t.num_children[4], 2);\n CU_ASSERT_EQUAL(tsk_tree_get_num_roots(&t), 1);\n tsk_tree_free(&t);\n\n ret = tsk_treeseq_simplify(&ts, sample_ids, 2, 0, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&simplified), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&simplified), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&simplified), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_edges(&simplified), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&simplified), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&simplified), 1);\n tsk_treeseq_free(&simplified);\n\n ret = tsk_treeseq_simplify(\n &ts, sample_ids, 2, TSK_SIMPLIFY_KEEP_UNARY, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n ret = tsk_treeseq_simplify(\n &ts, sample_ids, 2, TSK_SIMPLIFY_KEEP_UNARY_IN_INDIVIDUALS, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n ret = tsk_treeseq_simplify(&ts, sample_ids, 2, 0, &simplified_other, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(\n tsk_table_collection_equals(simplified.tables, simplified_other.tables, 0));\n tsk_treeseq_free(&simplified);\n tsk_treeseq_free(&simplified_other);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_unary_with_individuals(void)\n{\n int ret;\n const char *nodes = \"1 0 0 -1\\n\"\n \"1 0 0 0\\n\"\n \"0 1 0 -1\\n\"\n \"0 1 0 1\\n\"\n \"0 2 0 -1\\n\"\n \"0 3 0 -1\\n\"\n \"0 3 0 2\\n\"\n \"0 1 0 -1\\n\"\n \"0 1 0 3\\n\"\n \"0 0 0 -1\\n\"\n \"0 0 0 4\\n\"\n \"0 1 0 3\\n\";\n const char *edges = \"0 2 2 0\\n\"\n \"0 2 3 1\\n\"\n \"2 3 7 0\\n\"\n \"2 3 8 1,9\\n\"\n \"2 3 11 10\\n\"\n \"0 2 4 2,3\\n\"\n \"0 1 5 4\\n\"\n \"1 2 6 4\\n\";\n const char *individuals = \"0 0.5 -1,-1\\n\"\n \"0 1.5,3.1 -1,-1\\n\"\n \"0 2.1 0,1\\n\"\n \"0 3.2 1,2\\n\"\n \"0 4.2 2,3\\n\";\n const char *nodes_expect = \"1 0 0 -1\\n\"\n \"1 0 0 0\\n\"\n \"0 1 0 1\\n\"\n \"0 1 0 3\\n\"\n \"0 2 0 -1\\n\"\n \"0 3 0 2\\n\";\n const char *edges_expect = \"0 2 2 1\\n\"\n \"2 3 3 1\\n\"\n \"0 2 4 0,2\\n\"\n \"1 2 5 4\\n\";\n const char *individuals_expect = \"0 0.5 -1,-1\\n\"\n \"0 1.5,3.1 -1,-1\\n\"\n \"0 2.1 0,1\\n\"\n \"0 3.2 1,2\\n\";\n tsk_treeseq_t ts, simplified, expected;\n tsk_id_t sample_ids[] = { 0, 1 };\n\n tsk_treeseq_from_text(&ts, 3, nodes, edges, NULL, NULL, NULL, individuals, NULL, 0);\n tsk_treeseq_from_text(&expected, 3, nodes_expect, edges_expect, NULL, NULL, NULL,\n individuals_expect, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 3.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 12);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_individuals(&ts), 5);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_populations(&ts), 1);\n\n ret = tsk_treeseq_simplify(&ts, sample_ids, 2,\n TSK_SIMPLIFY_KEEP_UNARY_IN_INDIVIDUALS | TSK_SIMPLIFY_FILTER_INDIVIDUALS,\n &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(simplified.tables, expected.tables, 0));\n tsk_treeseq_free(&simplified);\n\n tsk_treeseq_free(&expected);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_non_sample_leaf_records(void)\n{\n int ret;\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 0 0\\n\"\n \"0 0 0\";\n const char *edges = \"0 1 2 0,1,3,4\\n\";\n const char *sites = \"0.1 0\\n\"\n \"0.2 0\\n\"\n \"0.3 0\\n\"\n \"0.4 0\\n\";\n const char *mutations = \"0 0 1\\n\"\n \"1 1 1\\n\"\n \"2 3 1\\n\"\n \"3 4 1\";\n tsk_treeseq_t ts, simplified;\n tsk_id_t sample_ids[] = { 0, 1 };\n tsk_vargen_t vargen;\n tsk_variant_t *var;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 5);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 4);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n\n ret = tsk_vargen_init(&vargen, &ts, NULL, 0, NULL, 0);\n tsk_vargen_print_state(&vargen, _devnull);\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 1);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 1);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 0);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_vargen_free(&vargen);\n\n ret = tsk_treeseq_simplify(&ts, sample_ids, 2, 0, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&simplified), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&simplified), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&simplified), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&simplified), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&simplified), 1);\n\n tsk_treeseq_free(&ts);\n tsk_treeseq_free(&simplified);\n}\n\nstatic void\ntest_simplest_degenerate_multiple_root_records(void)\n{\n\n int ret;\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 1 0\\n\";\n const char *edges = \"0 1 2 0\\n\"\n \"0 1 3 1\\n\";\n tsk_treeseq_t ts, simplified;\n tsk_tree_t t;\n tsk_id_t sample_ids[] = { 0, 1 };\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 4);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(tsk_tree_get_num_roots(&t), 2);\n CU_ASSERT_EQUAL(tsk_tree_get_left_root(&t), 2);\n CU_ASSERT_EQUAL(tsk_tree_get_right_root(&t), 3);\n CU_ASSERT_EQUAL(t.num_edges, 2);\n CU_ASSERT_EQUAL(t.right_sib[2], 3);\n CU_ASSERT_EQUAL(t.right_sib[3], TSK_NULL);\n CU_ASSERT_EQUAL(t.num_children[2], 1);\n CU_ASSERT_EQUAL(t.num_children[0], 0);\n\n ret = tsk_treeseq_simplify(&ts, sample_ids, 2, 0, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&simplified), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&simplified), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&simplified), 2);\n tsk_treeseq_free(&simplified);\n\n ret = tsk_treeseq_simplify(\n &ts, sample_ids, 2, TSK_SIMPLIFY_KEEP_UNARY, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n}\n\nstatic void\ntest_simplest_multiple_root_records(void)\n{\n int ret;\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 1 0\\n\";\n const char *edges = \"0 1 4 0,1\\n\"\n \"0 1 5 2,3\\n\";\n tsk_treeseq_t ts, simplified;\n tsk_id_t sample_ids[] = { 0, 1, 2, 3 };\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 4);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 6);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n\n ret = tsk_treeseq_simplify(&ts, sample_ids, 4, 0, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&simplified), 4);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&simplified), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&simplified), 6);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&simplified), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&simplified), 1);\n tsk_treeseq_free(&simplified);\n\n /* Make one tree degenerate */\n ret = tsk_treeseq_simplify(&ts, sample_ids, 3, 0, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&simplified), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&simplified), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&simplified), 4);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&simplified), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&simplified), 1);\n tsk_treeseq_free(&simplified);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_zero_root_tree(void)\n{\n int ret;\n const char *nodes = \"0 0 0\\n\"\n \"0 0 0\\n\"\n \"0 0 0\\n\"\n \"0 0 0\\n\"\n \"0 1 0\\n\"\n \"0 1 0\\n\";\n const char *edges = \"0 1 4 0,1\\n\"\n \"0 1 5 2,3\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 6);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(tsk_tree_get_num_roots(&t), 0);\n CU_ASSERT_EQUAL(t.num_edges, 4);\n CU_ASSERT_EQUAL(tsk_tree_get_left_root(&t), TSK_NULL);\n CU_ASSERT_EQUAL(tsk_tree_get_right_root(&t), TSK_NULL);\n CU_ASSERT_EQUAL(t.right_sib[2], 3);\n CU_ASSERT_EQUAL(t.right_sib[3], TSK_NULL);\n CU_ASSERT_EQUAL(t.num_children[0], 0);\n CU_ASSERT_EQUAL(t.num_children[4], 2);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_multi_root_tree(void)\n{\n int ret;\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\";\n const char *edges = \"0 1 3 1,2\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 4);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n\n ret = tsk_tree_init(&t, &ts, 0);\n\n tsk_tree_print_state(&t, _devnull);\n\n /* Make sure the initial roots are set correctly */\n CU_ASSERT_EQUAL(tsk_tree_get_left_root(&t), 0);\n CU_ASSERT_EQUAL(t.left_sib[0], TSK_NULL);\n CU_ASSERT_EQUAL(t.right_sib[0], 1);\n CU_ASSERT_EQUAL(t.left_sib[1], 0);\n CU_ASSERT_EQUAL(t.right_sib[1], 2);\n CU_ASSERT_EQUAL(t.left_sib[2], 1);\n CU_ASSERT_EQUAL(t.right_sib[2], TSK_NULL);\n\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(tsk_tree_get_num_roots(&t), 2);\n CU_ASSERT_EQUAL(tsk_tree_get_left_root(&t), 0);\n CU_ASSERT_EQUAL(t.right_sib[0], 3);\n CU_ASSERT_EQUAL(t.num_edges, 2);\n CU_ASSERT_EQUAL(t.num_children[0], 0);\n CU_ASSERT_EQUAL(t.num_children[3], 2);\n\n tsk_tree_print_state(&t, _devnull);\n\n CU_ASSERT_EQUAL(tsk_tree_set_root_threshold(&t, 1), TSK_ERR_UNSUPPORTED_OPERATION);\n ret = tsk_tree_next(&t);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_tree_set_root_threshold(&t, 0), TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_tree_set_root_threshold(&t, 2);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_tree_get_root_threshold(&t), 2);\n\n ret = tsk_tree_next(&t);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(tsk_tree_get_num_roots(&t), 1);\n CU_ASSERT_EQUAL(tsk_tree_get_left_root(&t), 3);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_tree_mrca(void)\n{\n int ret;\n tsk_table_collection_t tables;\n tsk_treeseq_t ts;\n tsk_tree_t t;\n tsk_id_t mrca, ret_id;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 1);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 1.0);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_tree_get_mrca(&t, 0, 0, &mrca);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(mrca, 0);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_root_mutations(void)\n{\n int ret;\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\";\n const char *edges = \"0 1 2 0,1\\n\";\n const char *sites = \"0.1 0\";\n const char *mutations = \"0 2 1\";\n tsk_flags_t options = 0;\n tsk_id_t sample_ids[] = { 0, 1 };\n tsk_treeseq_t ts, simplified;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 1);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 1);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n\n ret = tsk_treeseq_simplify(&ts, sample_ids, 2, options, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&simplified), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&simplified), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&simplified), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&simplified), 1);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&simplified), 1);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&simplified), 1);\n tsk_treeseq_free(&simplified);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_back_mutations(void)\n{\n int ret;\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 2 0\\n\";\n const char *edges = \"0 1 3 0,1\\n\"\n \"0 1 4 2,3\\n\";\n const char *sites = \"0.5 0\";\n const char *mutations = \"0 3 1 -1\\n\"\n \"0 0 0 0\";\n tsk_treeseq_t ts;\n tsk_vargen_t vargen;\n tsk_variant_t *var;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 5);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 1);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n\n ret = tsk_vargen_init(&vargen, &ts, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_vargen_next(&vargen, &var);\n CU_ASSERT_EQUAL_FATAL(ret, 1);\n CU_ASSERT_EQUAL(var->num_alleles, 2);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[0], \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(var->alleles[1], \"1\", 1);\n CU_ASSERT_EQUAL(var->genotypes[0], 0);\n CU_ASSERT_EQUAL(var->genotypes[1], 1);\n CU_ASSERT_EQUAL(var->genotypes[2], 0);\n CU_ASSERT_EQUAL(var->site.id, 0);\n CU_ASSERT_EQUAL(var->site.mutations_length, 2);\n tsk_vargen_free(&vargen);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_general_samples(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"1 0 0\";\n const char *edges = \"0 1 1 0,2\\n\";\n const char *sites = \"0.5 0\\n\"\n \"0.75 0\\n\";\n const char *mutations = \"0 2 1\\n\"\n \"1 0 1\";\n const tsk_id_t samples[2] = { 0, 2 };\n const tsk_id_t *s;\n int ret;\n\n tsk_treeseq_t ts, simplified;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n\n s = tsk_treeseq_get_samples(&ts);\n CU_ASSERT_FATAL(s != NULL);\n CU_ASSERT_EQUAL(s[0], 0);\n CU_ASSERT_EQUAL(s[1], 2);\n\n ret = tsk_treeseq_simplify(&ts, samples, 2, 0, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n s = tsk_treeseq_get_samples(&simplified);\n CU_ASSERT_FATAL(s != NULL);\n CU_ASSERT_EQUAL(s[0], 0);\n CU_ASSERT_EQUAL(s[1], 1);\n\n tsk_treeseq_free(&simplified);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_holey_tree_sequence(void)\n{\n const char *nodes_txt = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\";\n const char *edges_txt = \"0 1 2 0\\n\"\n \"2 3 2 0\\n\"\n \"0 1 2 1\\n\"\n \"2 3 2 1\\n\";\n const char *sites_txt = \"0.5 0\\n\"\n \"1.5 0\\n\"\n \"2.5 0\\n\";\n const char *mutations_txt = \"0 0 1\\n\"\n \"1 1 1\\n\"\n \"2 2 1\\n\";\n int ret;\n tsk_treeseq_t ts, simplified;\n tsk_id_t sample_ids[] = { 0, 1 };\n\n tsk_treeseq_from_text(\n &ts, 3, nodes_txt, edges_txt, NULL, sites_txt, mutations_txt, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 3.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 3);\n\n ret = tsk_treeseq_simplify(&ts, sample_ids, 2, 0, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n ret = tsk_treeseq_simplify(\n &ts, sample_ids, 2, TSK_SIMPLIFY_KEEP_UNARY, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_holey_tsk_treeseq_mutation_parents(void)\n{\n const char *nodes_txt = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\";\n const char *edges_txt = \"0 1 2 0\\n\"\n \"2 3 2 0\\n\"\n \"0 1 2 1\\n\"\n \"2 3 2 1\\n\";\n const char *sites_txt = \"0.5 0\\n\"\n \"1.5 0\\n\"\n \"2.5 0\\n\";\n const char *mutations_txt = \"0 0 1\\n\"\n \"0 0 1\\n\"\n \"1 1 1\\n\"\n \"1 1 1\\n\"\n \"2 2 1\\n\"\n \"2 2 1\\n\";\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n int ret;\n\n tsk_treeseq_from_text(\n &ts, 3, nodes_txt, edges_txt, NULL, sites_txt, mutations_txt, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 6);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 3);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tables.mutations.parent[0], -1);\n CU_ASSERT_EQUAL(tables.mutations.parent[1], 0);\n CU_ASSERT_EQUAL(tables.mutations.parent[2], -1);\n CU_ASSERT_EQUAL(tables.mutations.parent[3], 2);\n CU_ASSERT_EQUAL(tables.mutations.parent[4], -1);\n CU_ASSERT_EQUAL(tables.mutations.parent[5], 4);\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_initial_gap_tree_sequence(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\";\n const char *edges = \"2 3 2 0,1\\n\";\n const char *sites = \"0.5 0\\n\"\n \"1.5 0\\n\"\n \"2.5 0\\n\";\n const char *mutations = \"0 0 1\\n\"\n \"1 1 1\\n\"\n \"2 2 1\";\n int ret;\n tsk_treeseq_t ts, simplified;\n const tsk_id_t z = TSK_NULL;\n tsk_id_t parents[] = {\n z,\n z,\n z,\n 2,\n 2,\n z,\n };\n tsk_size_t num_trees = 2;\n tsk_id_t sample_ids[] = { 0, 1 };\n\n tsk_treeseq_from_text(&ts, 3, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 3.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 2);\n\n verify_trees(&ts, num_trees, parents);\n\n ret = tsk_treeseq_simplify(&ts, sample_ids, 2, 0, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n ret = tsk_treeseq_simplify(\n &ts, sample_ids, 2, TSK_SIMPLIFY_KEEP_UNARY, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_initial_gap_zero_roots(void)\n{\n const char *nodes = \"0 0 0\\n\"\n \"0 0 0\\n\"\n \"0 1 0\";\n const char *edges = \"2 3 2 0,1\\n\";\n int ret;\n tsk_treeseq_t ts;\n const tsk_id_t z = TSK_NULL;\n tsk_id_t parents[] = {\n z,\n z,\n z,\n 2,\n 2,\n z,\n };\n uint32_t num_trees = 2;\n tsk_tree_t tree;\n\n tsk_treeseq_from_text(&ts, 3, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 3.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 2);\n\n verify_trees(&ts, num_trees, parents);\n\n ret = tsk_tree_init(&tree, &ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(tsk_tree_get_left_root(&tree), TSK_NULL);\n CU_ASSERT_EQUAL(tsk_tree_get_num_roots(&tree), 0);\n\n ret = tsk_tree_next(&tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(tsk_tree_get_left_root(&tree), TSK_NULL);\n CU_ASSERT_EQUAL(tsk_tree_get_num_roots(&tree), 0);\n CU_ASSERT_EQUAL(tree.parent[0], 2);\n CU_ASSERT_EQUAL(tree.parent[1], 2);\n CU_ASSERT_EQUAL(tree.num_children[2], 2);\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_holey_tsk_treeseq_zero_roots(void)\n{\n const char *nodes_txt = \"0 0 0\\n\"\n \"0 0 0\\n\"\n \"0 1 0\";\n const char *edges_txt = \"0 1 2 0\\n\"\n \"2 3 2 0\\n\"\n \"0 1 2 1\\n\"\n \"2 3 2 1\\n\";\n int ret;\n tsk_treeseq_t ts;\n const tsk_id_t z = TSK_NULL;\n tsk_id_t parents[] = {\n 2,\n 2,\n z,\n z,\n z,\n z,\n 2,\n 2,\n z,\n };\n uint32_t num_trees = 3;\n tsk_tree_t tree;\n\n tsk_treeseq_from_text(&ts, 3, nodes_txt, edges_txt, NULL, NULL, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 3.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 3);\n\n verify_trees(&ts, num_trees, parents);\n\n ret = tsk_tree_init(&tree, &ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(tsk_tree_get_left_root(&tree), TSK_NULL);\n CU_ASSERT_EQUAL(tree.parent[0], 2);\n CU_ASSERT_EQUAL(tree.parent[1], 2);\n CU_ASSERT_EQUAL(tsk_tree_get_num_roots(&tree), 0);\n CU_ASSERT_EQUAL(tree.num_children[2], 2);\n\n ret = tsk_tree_next(&tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(tsk_tree_get_left_root(&tree), TSK_NULL);\n CU_ASSERT_EQUAL(tsk_tree_get_num_roots(&tree), 0);\n CU_ASSERT_EQUAL(tree.num_children[2], 0);\n\n ret = tsk_tree_next(&tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(tsk_tree_get_left_root(&tree), TSK_NULL);\n CU_ASSERT_EQUAL(tsk_tree_get_num_roots(&tree), 0);\n CU_ASSERT_EQUAL(tree.parent[0], 2);\n CU_ASSERT_EQUAL(tree.parent[1], 2);\n CU_ASSERT_EQUAL(tree.num_children[2], 2);\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_initial_gap_tsk_treeseq_mutation_parents(void)\n{\n const char *nodes_txt = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\";\n const char *edges_txt = \"2 3 2 0,1\\n\";\n const char *sites_txt = \"0.5 0\\n\"\n \"1.5 0\\n\"\n \"2.5 0\\n\";\n const char *mutations_txt = \"0 0 1\\n\"\n \"0 0 1\\n\"\n \"1 1 1\\n\"\n \"1 1 1\\n\"\n \"2 2 1\\n\"\n \"2 2 1\\n\";\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n int ret;\n\n tsk_treeseq_from_text(\n &ts, 3, nodes_txt, edges_txt, NULL, sites_txt, mutations_txt, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 6);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 2);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tables.mutations.parent[0], -1);\n CU_ASSERT_EQUAL(tables.mutations.parent[1], 0);\n CU_ASSERT_EQUAL(tables.mutations.parent[2], -1);\n CU_ASSERT_EQUAL(tables.mutations.parent[3], 2);\n CU_ASSERT_EQUAL(tables.mutations.parent[4], -1);\n CU_ASSERT_EQUAL(tables.mutations.parent[5], 4);\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_final_gap_tree_sequence(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\";\n const char *edges = \"0 2 2 0,1\\n\";\n const char *sites = \"0.5 0\\n\"\n \"1.5 0\\n\"\n \"2.5 0\\n\";\n const char *mutations = \"0 0 1\\n\"\n \"1 1 1\\n\"\n \"2 0 1\";\n tsk_treeseq_t ts;\n const tsk_id_t z = TSK_NULL;\n tsk_id_t parents[] = {\n 2,\n 2,\n z,\n z,\n z,\n z,\n };\n uint32_t num_trees = 2;\n\n tsk_treeseq_from_text(&ts, 3, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 3.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 2);\n\n verify_trees(&ts, num_trees, parents);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_final_gap_tsk_treeseq_mutation_parents(void)\n{\n const char *nodes_txt = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\";\n const char *edges_txt = \"0 2 2 0,1\\n\";\n const char *sites_txt = \"0.5 0\\n\"\n \"1.5 0\\n\"\n \"2.5 0\\n\";\n const char *mutations_txt = \"0 0 1\\n\"\n \"0 0 1\\n\"\n \"1 1 1\\n\"\n \"1 1 1\\n\"\n \"2 0 1\\n\"\n \"2 0 1\\n\";\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n int ret;\n\n tsk_treeseq_from_text(\n &ts, 3, nodes_txt, edges_txt, NULL, sites_txt, mutations_txt, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 6);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 2);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tables.mutations.parent[0], -1);\n CU_ASSERT_EQUAL(tables.mutations.parent[1], 0);\n CU_ASSERT_EQUAL(tables.mutations.parent[2], -1);\n CU_ASSERT_EQUAL(tables.mutations.parent[3], 2);\n CU_ASSERT_EQUAL(tables.mutations.parent[4], -1);\n CU_ASSERT_EQUAL(tables.mutations.parent[5], 4);\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_individuals(void)\n{\n const char *individuals = \"1 0.25 -1,-1\\n\"\n \"2 0.5,0.25 -1,-1\\n\"\n \"3 0.75 0,1\\n\";\n const char *nodes = \"1 0 -1 -1\\n\"\n \"1 0 -1 1\\n\"\n \"0 0 -1 -1\\n\"\n \"1 0 -1 0\\n\"\n \"0 0 -1 1\\n\"\n \"0 0 -1 2\\n\";\n tsk_table_collection_t tables;\n tsk_treeseq_t ts;\n tsk_node_t node;\n tsk_individual_t individual;\n tsk_flags_t load_flags = TSK_TS_INIT_BUILD_INDEXES;\n int ret;\n tsk_id_t pat_id, mat_id;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1.0;\n parse_individuals(individuals, &tables.individuals);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.num_rows, 3);\n\n parse_nodes(nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 6);\n\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_get_node(&ts, 0, &node);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(node.individual, TSK_NULL);\n\n ret = tsk_treeseq_get_node(&ts, 1, &node);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(node.individual, 1);\n\n ret = tsk_treeseq_get_individual(&ts, 0, &individual);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(individual.id, 0);\n CU_ASSERT_EQUAL_FATAL(individual.flags, 1);\n CU_ASSERT_EQUAL_FATAL(individual.location_length, 1);\n CU_ASSERT_EQUAL_FATAL(individual.location[0], 0.25);\n CU_ASSERT_EQUAL_FATAL(individual.parents_length, 2);\n CU_ASSERT_EQUAL_FATAL(individual.parents[0], -1);\n CU_ASSERT_EQUAL_FATAL(individual.parents[1], -1);\n pat_id = individual.id;\n CU_ASSERT_EQUAL_FATAL(individual.nodes_length, 1);\n CU_ASSERT_EQUAL_FATAL(individual.nodes[0], 3);\n\n ret = tsk_treeseq_get_individual(&ts, 1, &individual);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(individual.id, 1);\n CU_ASSERT_EQUAL_FATAL(individual.flags, 2);\n CU_ASSERT_EQUAL_FATAL(individual.location_length, 2);\n CU_ASSERT_EQUAL_FATAL(individual.location[0], 0.5);\n CU_ASSERT_EQUAL_FATAL(individual.location[1], 0.25);\n CU_ASSERT_EQUAL_FATAL(individual.parents_length, 2);\n CU_ASSERT_EQUAL_FATAL(individual.parents[0], -1);\n CU_ASSERT_EQUAL_FATAL(individual.parents[1], -1);\n mat_id = individual.id;\n CU_ASSERT_EQUAL_FATAL(individual.nodes_length, 2);\n CU_ASSERT_EQUAL_FATAL(individual.nodes[0], 1);\n CU_ASSERT_EQUAL_FATAL(individual.nodes[1], 4);\n\n ret = tsk_treeseq_get_individual(&ts, 2, &individual);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(individual.id, 2);\n CU_ASSERT_EQUAL_FATAL(individual.flags, 3);\n CU_ASSERT_EQUAL_FATAL(individual.location_length, 1);\n CU_ASSERT_EQUAL_FATAL(individual.location[0], 0.75);\n CU_ASSERT_EQUAL_FATAL(individual.parents_length, 2);\n CU_ASSERT_EQUAL_FATAL(individual.parents[0], pat_id);\n CU_ASSERT_EQUAL_FATAL(individual.parents[1], mat_id);\n CU_ASSERT_EQUAL_FATAL(individual.nodes_length, 1);\n CU_ASSERT_EQUAL_FATAL(individual.nodes[0], 5);\n\n ret = tsk_treeseq_get_individual(&ts, 3, &individual);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n\n /* NaN/ifinity values are allowed in locations they do not\n * affect the integrity of the model. */\n tables.individuals.location[0] = NAN;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_treeseq_get_individual(&ts, 0, &individual);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT(!tsk_isfinite(individual.location[0]));\n tsk_treeseq_free(&ts);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_bad_individuals(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\";\n const char *edges = \"0 1 2 0\\n\"\n \"0 1 2 1\\n\"\n \"0 1 4 3\\n\";\n const char *individuals = \"1 0.25 -1\\n\"\n \"2 0.5,0.25 0\\n\";\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_flags_t load_flags = TSK_TS_INIT_BUILD_INDEXES;\n tsk_id_t ret_id;\n int ret;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1.0;\n parse_nodes(nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 5);\n parse_edges(edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 3);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /* Make sure we have a good set of records */\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n\n /* Bad individual ID */\n tables.nodes.individual[0] = -2;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.nodes.individual[0] = TSK_NULL;\n\n /* Bad individual ID */\n tables.nodes.individual[0] = 0;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.nodes.individual[0] = TSK_NULL;\n\n /* Add two individuals */\n parse_individuals(individuals, &tables.individuals);\n CU_ASSERT_EQUAL_FATAL(tables.individuals.num_rows, 2);\n\n /* Make sure we have a good set of records */\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n\n /* Bad individual ID */\n tables.nodes.individual[0] = 2;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.nodes.individual[0] = TSK_NULL;\n\n /* Bad parent ID */\n tables.individuals.parents[0] = -2;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.individuals.parents[0] = 42;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.individuals.parents[0] = TSK_NULL;\n\n /* Parent is self */\n tables.individuals.parents[0] = 0;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_INDIVIDUAL_SELF_PARENT);\n tsk_treeseq_free(&ts);\n tables.individuals.parents[0] = TSK_NULL;\n\n /* Unsorted individuals are OK*/\n tables.individuals.parents[0] = 1;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, 0);\n tsk_treeseq_free(&ts);\n tables.individuals.parents[0] = TSK_NULL;\n\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_bad_edges(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\";\n const char *edges = \"0 1 2 0\\n\"\n \"0 1 2 1\\n\"\n \"0 1 4 3\\n\";\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n int ret;\n tsk_id_t ret_id;\n tsk_flags_t load_flags = TSK_TS_INIT_BUILD_INDEXES;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1.0;\n parse_nodes(nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 5);\n parse_edges(edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 3);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /* Make sure we have a good set of records */\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n\n /* Bad population ID */\n tables.nodes.population[0] = -2;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.nodes.population[0] = 0;\n\n /* Bad population ID */\n tables.nodes.population[0] = 1;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.nodes.population[0] = 0;\n\n /* Bad interval */\n tables.edges.right[0] = 0.0;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_EDGE_INTERVAL);\n tsk_treeseq_free(&ts);\n tables.edges.right[0] = 1.0;\n\n /* Nonfinite coords */\n tables.edges.left[0] = NAN;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_GENOME_COORDS_NONFINITE);\n tsk_treeseq_free(&ts);\n tables.edges.left[0] = 1.0;\n\n tables.edges.left[0] = INFINITY;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_GENOME_COORDS_NONFINITE);\n tsk_treeseq_free(&ts);\n tables.edges.left[0] = 1.0;\n\n tables.edges.right[0] = NAN;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_GENOME_COORDS_NONFINITE);\n tsk_treeseq_free(&ts);\n tables.edges.right[0] = 1.0;\n\n tables.edges.right[0] = -INFINITY;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_GENOME_COORDS_NONFINITE);\n tsk_treeseq_free(&ts);\n tables.edges.right[0] = 1.0;\n\n /* Left coordinate < 0. */\n tables.edges.left[0] = -1;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_LEFT_LESS_ZERO);\n tsk_treeseq_free(&ts);\n tables.edges.left[0] = 0.0;\n\n /* Right coordinate > sequence length. */\n tables.edges.right[0] = 2.0;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_RIGHT_GREATER_SEQ_LENGTH);\n tsk_treeseq_free(&ts);\n tables.edges.right[0] = 1.0;\n\n /* Duplicate records */\n tables.edges.child[0] = 1;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_DUPLICATE_EDGES);\n tsk_treeseq_free(&ts);\n tables.edges.child[0] = 0;\n\n /* Duplicate records */\n tables.edges.child[0] = 1;\n tables.edges.left[0] = 0.5;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_EDGES_NOT_SORTED_LEFT);\n tsk_treeseq_free(&ts);\n tables.edges.child[0] = 0;\n tables.edges.left[0] = 0.0;\n\n /* child node == parent */\n tables.edges.child[1] = 2;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_NODE_TIME_ORDERING);\n tsk_treeseq_free(&ts);\n tables.edges.child[1] = 1;\n\n /* Unsorted child nodes */\n tables.edges.child[0] = 1;\n tables.edges.child[1] = 0;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_EDGES_NOT_SORTED_CHILD);\n tsk_treeseq_free(&ts);\n tables.edges.child[0] = 0;\n tables.edges.child[1] = 1;\n\n /* discontinuous parent nodes */\n /* Swap rows 1 and 2 */\n tables.edges.parent[1] = 4;\n tables.edges.child[1] = 3;\n tables.edges.parent[2] = 2;\n tables.edges.child[2] = 1;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_EDGES_NONCONTIGUOUS_PARENTS);\n tsk_treeseq_free(&ts);\n tables.edges.parent[2] = 4;\n tables.edges.child[2] = 3;\n tables.edges.parent[1] = 2;\n tables.edges.child[1] = 1;\n\n /* Null parent */\n tables.edges.parent[0] = TSK_NULL;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NULL_PARENT);\n tsk_treeseq_free(&ts);\n tables.edges.parent[0] = 2;\n\n /* parent not in nodes list */\n tables.nodes.num_rows = 2;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.nodes.num_rows = 5;\n\n /* parent negative */\n tables.edges.parent[0] = -2;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.edges.parent[0] = 2;\n\n /* Null child */\n tables.edges.child[0] = TSK_NULL;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NULL_CHILD);\n tsk_treeseq_free(&ts);\n tables.edges.child[0] = 0;\n\n /* child node reference out of bounds */\n tables.edges.child[0] = 100;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.edges.child[0] = 0;\n\n /* child node reference negative */\n tables.edges.child[0] = -2;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.edges.child[0] = 0;\n\n /* Make sure we've preserved a good tree sequence */\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, 0);\n tsk_treeseq_free(&ts);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_bad_indexes(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\";\n const char *edges = \"0 1 2 0\\n\"\n \"0 1 2 1\\n\"\n \"0 1 4 3\\n\";\n tsk_table_collection_t tables;\n tsk_id_t bad_indexes[] = { -1, 3, 4, 1000 };\n tsk_size_t j;\n tsk_id_t ret_id;\n tsk_id_t ret_num_trees;\n int ret;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1.0;\n parse_nodes(nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 5);\n parse_edges(edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 3);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /* Make sure we have a good set of records */\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = (int) tsk_table_collection_check_integrity(&tables, TSK_CHECK_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLES_NOT_INDEXED);\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret_num_trees = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n /* TSK_CHECK_TREES returns the number of trees */\n CU_ASSERT_EQUAL_FATAL(ret_num_trees, 1);\n\n for (j = 0; j < sizeof(bad_indexes) / sizeof(*bad_indexes); j++) {\n tables.indexes.edge_insertion_order[0] = bad_indexes[j];\n ret_num_trees = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n CU_ASSERT_EQUAL_FATAL(ret_num_trees, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n tables.indexes.edge_insertion_order[0] = 0;\n\n tables.indexes.edge_removal_order[0] = bad_indexes[j];\n ret_num_trees = tsk_table_collection_check_integrity(&tables, TSK_CHECK_TREES);\n CU_ASSERT_EQUAL_FATAL(ret_num_trees, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n tables.indexes.edge_removal_order[0] = 0;\n }\n\n ret = tsk_table_collection_drop_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = (int) tsk_table_collection_check_integrity(&tables, TSK_CHECK_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TABLES_NOT_INDEXED);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_bad_migrations(void)\n{\n tsk_table_collection_t tables;\n int ret;\n tsk_id_t ret_id;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n /* insert two populations and one node to refer to. */\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n /* One migration, node 0 goes from population 0 to 1. */\n ret_id\n = tsk_migration_table_add_row(&tables.migrations, 0, 1, 0, 0, 1, 1.0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /* We only need basic intregity checks for migrations */\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Bad node reference */\n tables.migrations.node[0] = -1;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tables.migrations.node[0] = 0;\n\n /* Bad node reference */\n tables.migrations.node[0] = 1;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tables.migrations.node[0] = 0;\n\n /* Bad population reference */\n tables.migrations.source[0] = -1;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n tables.migrations.source[0] = 0;\n\n /* Bad population reference */\n tables.migrations.source[0] = 2;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n tables.migrations.source[0] = 0;\n\n /* Bad population reference */\n tables.migrations.dest[0] = -1;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n tables.migrations.dest[0] = 1;\n\n /* Bad population reference */\n tables.migrations.dest[0] = 2;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n tables.migrations.dest[0] = 1;\n\n /* Bad time values */\n tables.migrations.time[0] = NAN;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_TIME_NONFINITE);\n tables.migrations.time[0] = 1.0;\n\n tables.migrations.time[0] = INFINITY;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_TIME_NONFINITE);\n tables.migrations.time[0] = 1.0;\n\n /* Bad left coordinate */\n tables.migrations.left[0] = -1;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_LEFT_LESS_ZERO);\n tables.migrations.left[0] = 0;\n\n tables.migrations.left[0] = NAN;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_GENOME_COORDS_NONFINITE);\n tables.migrations.left[0] = 0;\n\n tables.migrations.left[0] = -INFINITY;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_GENOME_COORDS_NONFINITE);\n tables.migrations.left[0] = 0;\n\n /* Bad right coordinate */\n tables.migrations.right[0] = 2;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_RIGHT_GREATER_SEQ_LENGTH);\n tables.migrations.right[0] = 1;\n\n tables.migrations.right[0] = NAN;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_GENOME_COORDS_NONFINITE);\n tables.migrations.right[0] = 1;\n\n tables.migrations.right[0] = INFINITY;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_GENOME_COORDS_NONFINITE);\n tables.migrations.right[0] = 1;\n\n /* Bad interval coordinate */\n tables.migrations.right[0] = 0;\n ret = (int) tsk_table_collection_check_integrity(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_EDGE_INTERVAL);\n tables.migrations.right[0] = 1;\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_migration_simplify(void)\n{\n tsk_table_collection_t tables;\n int ret;\n tsk_id_t ret_id;\n tsk_id_t samples[] = { 0, 1 };\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n /* insert two populations and one node to refer to. */\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_node_table_add_row(\n &tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n /* One migration, node 0 goes from population 0 to 1. */\n ret_id\n = tsk_migration_table_add_row(&tables.migrations, 0, 1, 0, 0, 1, 1.0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n ret = tsk_table_collection_simplify(&tables, samples, 2, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SIMPLIFY_MIGRATIONS_NOT_SUPPORTED);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_overlapping_parents(void)\n{\n const char *nodes = \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"0 1 -1\\n\";\n const char *edges = \"0 1 2 0\\n\"\n \"0 1 2 1\\n\";\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_tree_t tree;\n int ret;\n tsk_flags_t load_flags = TSK_TS_INIT_BUILD_INDEXES;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1;\n parse_nodes(nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 3);\n parse_edges(edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 2);\n\n tables.edges.left[0] = 0;\n tables.edges.parent[0] = 2;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_init(&tree, &ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(tree.parent[0], 2);\n CU_ASSERT_EQUAL(tree.parent[1], 2);\n CU_ASSERT_EQUAL(tree.left_sib[2], TSK_NULL);\n CU_ASSERT_EQUAL(tree.right_sib[2], TSK_NULL);\n CU_ASSERT_EQUAL(tree.left_child[2], 0);\n CU_ASSERT_EQUAL(tree.right_child[2], 1);\n CU_ASSERT_EQUAL(tree.left_sib[0], TSK_NULL);\n CU_ASSERT_EQUAL(tree.right_sib[0], 1);\n CU_ASSERT_EQUAL(tree.left_sib[1], 0);\n CU_ASSERT_EQUAL(tree.right_sib[1], TSK_NULL);\n CU_ASSERT_EQUAL(tree.num_children[2], 2);\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_contradictory_children(void)\n{\n const char *nodes = \"1 0 -1\\n\"\n \"1 1 -1\\n\"\n \"0 1 -1\\n\";\n const char *edges = \"0 1 1 0\\n\"\n \"0 1 2 0\\n\";\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n int ret;\n tsk_flags_t load_flags = TSK_TS_INIT_BUILD_INDEXES;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n parse_nodes(nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 3);\n parse_edges(edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 2);\n tables.sequence_length = 1.0;\n\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_EDGES_CONTRADICTORY_CHILDREN);\n\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_overlapping_edges_simplify(void)\n{\n const char *nodes = \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"0 1 -1\";\n const char *edges = \"0 2 3 0\\n\"\n \"1 3 3 1\\n\"\n \"0 3 3 2\\n\";\n tsk_id_t samples[] = { 0, 1, 2 };\n tsk_table_collection_t tables;\n int ret;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 3;\n parse_nodes(nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 4);\n parse_edges(edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 3);\n\n ret = tsk_table_collection_simplify(&tables, samples, 3, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL(tables.nodes.num_rows, 4);\n CU_ASSERT_EQUAL(tables.edges.num_rows, 3);\n\n /* Identical to the input.\n 0 2 3 0\n 1 3 3 1\n 0 3 3 2\n */\n CU_ASSERT_EQUAL(tables.edges.left[0], 0);\n CU_ASSERT_EQUAL(tables.edges.left[1], 1);\n CU_ASSERT_EQUAL(tables.edges.left[2], 0);\n CU_ASSERT_EQUAL(tables.edges.right[0], 2);\n CU_ASSERT_EQUAL(tables.edges.right[1], 3);\n CU_ASSERT_EQUAL(tables.edges.right[2], 3);\n CU_ASSERT_EQUAL(tables.edges.parent[0], 3);\n CU_ASSERT_EQUAL(tables.edges.parent[1], 3);\n CU_ASSERT_EQUAL(tables.edges.parent[2], 3);\n CU_ASSERT_EQUAL(tables.edges.child[0], 0);\n CU_ASSERT_EQUAL(tables.edges.child[1], 1);\n CU_ASSERT_EQUAL(tables.edges.child[2], 2);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_overlapping_unary_edges_simplify(void)\n{\n const char *nodes = \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"0 1 -1\";\n const char *edges = \"0 2 2 0\\n\"\n \"1 3 2 1\\n\";\n tsk_id_t samples[] = { 0, 1 };\n tsk_table_collection_t tables;\n int ret;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 3;\n parse_nodes(nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 3);\n parse_edges(edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 2);\n\n ret = tsk_table_collection_simplify(&tables, samples, 2, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL(tables.nodes.num_rows, 3);\n CU_ASSERT_EQUAL(tables.edges.num_rows, 2);\n\n /* Because we only sample 0 and 1, the flanking unary edges are removed\n 1 2 2 0\n 1 2 2 1\n */\n CU_ASSERT_EQUAL(tables.edges.left[0], 1);\n CU_ASSERT_EQUAL(tables.edges.right[0], 2);\n CU_ASSERT_EQUAL(tables.edges.parent[0], 2);\n CU_ASSERT_EQUAL(tables.edges.child[0], 0);\n CU_ASSERT_EQUAL(tables.edges.left[1], 1);\n CU_ASSERT_EQUAL(tables.edges.right[1], 2);\n CU_ASSERT_EQUAL(tables.edges.parent[1], 2);\n CU_ASSERT_EQUAL(tables.edges.child[1], 1);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_overlapping_unary_edges_internal_samples_simplify(void)\n{\n const char *nodes = \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 1 -1\";\n const char *edges = \"0 2 2 0\\n\"\n \"1 3 2 1\\n\";\n tsk_id_t samples[] = { 0, 1, 2 };\n tsk_table_collection_t tables;\n int ret;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 3;\n parse_nodes(nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 3);\n parse_edges(edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 2);\n\n ret = tsk_table_collection_simplify(&tables, samples, 3, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL(tables.nodes.num_rows, 3);\n CU_ASSERT_EQUAL(tables.edges.num_rows, 2);\n /* Identical to the input.\n 0 2 2 0\n 1 3 2 1\n */\n CU_ASSERT_EQUAL(tables.edges.left[0], 0);\n CU_ASSERT_EQUAL(tables.edges.left[1], 1);\n CU_ASSERT_EQUAL(tables.edges.right[0], 2);\n CU_ASSERT_EQUAL(tables.edges.right[1], 3);\n CU_ASSERT_EQUAL(tables.edges.parent[0], 2);\n CU_ASSERT_EQUAL(tables.edges.parent[1], 2);\n CU_ASSERT_EQUAL(tables.edges.child[0], 0);\n CU_ASSERT_EQUAL(tables.edges.child[1], 1);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_reduce_site_topology(void)\n{\n /* Two trees side by side, with a site on the second one. The first\n * tree should disappear. */\n const char *nodes = \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"0 1 -1\\n\"\n \"0 2 -1\\n\";\n const char *edges = \"0 1 2 0\\n\"\n \"0 1 2 1\\n\"\n \"1 2 3 0\\n\"\n \"1 2 3 1\\n\";\n const char *sites = \"1.0 0\\n\";\n tsk_id_t samples[] = { 0, 1 };\n tsk_table_collection_t tables;\n int ret;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 2;\n parse_nodes(nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 4);\n parse_edges(edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 4);\n parse_sites(sites, &tables.sites);\n CU_ASSERT_EQUAL_FATAL(tables.sites.num_rows, 1);\n\n ret = tsk_table_collection_simplify(\n &tables, samples, 2, TSK_SIMPLIFY_REDUCE_TO_SITE_TOPOLOGY, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL(tables.nodes.num_rows, 3);\n CU_ASSERT_EQUAL(tables.edges.num_rows, 2);\n CU_ASSERT_EQUAL(tables.edges.left[0], 0);\n CU_ASSERT_EQUAL(tables.edges.left[1], 0);\n CU_ASSERT_EQUAL(tables.edges.right[0], 2);\n CU_ASSERT_EQUAL(tables.edges.right[1], 2);\n CU_ASSERT_EQUAL(tables.edges.parent[0], 2);\n CU_ASSERT_EQUAL(tables.edges.parent[1], 2);\n CU_ASSERT_EQUAL(tables.edges.child[0], 0);\n CU_ASSERT_EQUAL(tables.edges.child[1], 1);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_simplify_defragment(void)\n{\n const char *nodes = \"0 2 -1\\n\"\n \"0 2 -1\\n\"\n \"0 2 -1\\n\"\n \"0 2 -1\\n\"\n \"0 2 -1\\n\"\n \"0 2 -1\\n\"\n \"0 1 -1\\n\"\n \"0 1 -1\\n\"\n \"0 1 -1\\n\"\n \"0 1 -1\\n\"\n \"0 1 -1\\n\"\n \"0 1 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\"\n \"1 0 -1\\n\";\n const char *edges = \"0.00000000 0.20784841 8 12\\n\"\n \"0.00000000 0.42202433 8 15\\n\"\n \"0.00000000 0.63541014 8 16\\n\"\n \"0.42202433 1.00000000 9 15\\n\"\n \"0.00000000 1.00000000 9 17\\n\"\n \"0.00000000 1.00000000 10 14\\n\"\n \"0.20784841 1.00000000 11 12\\n\"\n \"0.00000000 1.00000000 11 13\\n\"\n \"0.63541014 1.00000000 11 16\\n\"\n \"0.00000000 1.00000000 0 10\\n\"\n \"0.62102072 1.00000000 1 9\\n\"\n \"0.00000000 1.00000000 1 11\\n\"\n \"0.00000000 0.26002984 2 6\\n\"\n \"0.26002984 1.00000000 2 6\\n\"\n \"0.00000000 0.62102072 2 9\\n\"\n \"0.55150554 1.00000000 3 8\\n\"\n \"0.00000000 1.00000000 4 7\\n\"\n \"0.00000000 0.55150554 5 8\\n\";\n\n tsk_id_t samples[] = { 12, 13, 14, 15, 16, 17 };\n tsk_table_collection_t tables;\n int ret;\n\n /* This was the simplest example I could find that exercised the\n * inner loops of the simplifier_extract_ancestry function */\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n parse_nodes(nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 18);\n parse_edges(edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 18);\n\n ret = tsk_table_collection_simplify(&tables, samples, 6, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL(tables.nodes.num_rows, 10);\n CU_ASSERT_EQUAL(tables.edges.num_rows, 10);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_population_filter(void)\n{\n tsk_table_collection_t tables;\n tsk_id_t samples[] = { 0, 1 };\n int ret;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1;\n tsk_population_table_add_row(&tables.populations, \"0\", 1);\n tsk_population_table_add_row(&tables.populations, \"1\", 1);\n tsk_population_table_add_row(&tables.populations, \"2\", 1);\n /* Two nodes referring to population 1 */\n tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, 1, TSK_NULL, NULL, 0);\n tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, 1, TSK_NULL, NULL, 0);\n\n ret = tsk_table_collection_simplify(&tables, samples, 2, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tables.nodes.num_rows, 2);\n CU_ASSERT_EQUAL(tables.populations.num_rows, 3);\n CU_ASSERT_EQUAL(tables.populations.metadata[0], '0');\n CU_ASSERT_EQUAL(tables.populations.metadata[1], '1');\n CU_ASSERT_EQUAL(tables.populations.metadata[2], '2');\n\n ret = tsk_table_collection_simplify(\n &tables, samples, 2, TSK_SIMPLIFY_FILTER_POPULATIONS, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tables.nodes.num_rows, 2);\n CU_ASSERT_EQUAL(tables.nodes.population[0], 0);\n CU_ASSERT_EQUAL(tables.nodes.population[1], 0);\n CU_ASSERT_EQUAL(tables.populations.num_rows, 1);\n CU_ASSERT_EQUAL(tables.populations.metadata[0], '1');\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_individual_filter(void)\n{\n tsk_table_collection_t tables;\n tsk_id_t samples[] = { 0, 1 };\n int ret;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1;\n tsk_individual_table_add_row(&tables.individuals, 0, NULL, 0, NULL, 0, \"0\", 1);\n tsk_individual_table_add_row(&tables.individuals, 0, NULL, 0, NULL, 0, \"1\", 1);\n tsk_individual_table_add_row(&tables.individuals, 0, NULL, 0, NULL, 0, \"2\", 1);\n /* Two nodes referring to individual 1 */\n tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, 1, NULL, 0);\n tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 0.0, TSK_NULL, 1, NULL, 0);\n\n ret = tsk_table_collection_simplify(&tables, samples, 2, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tables.nodes.num_rows, 2);\n CU_ASSERT_EQUAL(tables.individuals.num_rows, 3);\n CU_ASSERT_EQUAL(tables.individuals.metadata[0], '0');\n CU_ASSERT_EQUAL(tables.individuals.metadata[1], '1');\n CU_ASSERT_EQUAL(tables.individuals.metadata[2], '2');\n\n ret = tsk_table_collection_simplify(\n &tables, samples, 2, TSK_SIMPLIFY_FILTER_INDIVIDUALS, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tables.nodes.num_rows, 2);\n CU_ASSERT_EQUAL(tables.nodes.individual[0], 0);\n CU_ASSERT_EQUAL(tables.nodes.individual[1], 0);\n CU_ASSERT_EQUAL(tables.individuals.num_rows, 1);\n CU_ASSERT_EQUAL(tables.individuals.metadata[0], '1');\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_simplest_no_node_filter(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 1 0\"; /* unreferenced node */\n const char *edges = \"0 1 2 0,1\\n\";\n tsk_treeseq_t ts, simplified;\n tsk_id_t sample_ids[] = { 0, 1 };\n tsk_id_t node_map[] = { -1, -1, -1, -1 };\n tsk_id_t j;\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n\n ret = tsk_treeseq_simplify(\n &ts, NULL, 0, TSK_SIMPLIFY_NO_FILTER_NODES, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n ret = tsk_treeseq_simplify(\n &ts, sample_ids, 2, TSK_SIMPLIFY_NO_FILTER_NODES, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n /* Reversing sample order makes no difference */\n sample_ids[0] = 1;\n sample_ids[1] = 0;\n ret = tsk_treeseq_simplify(\n &ts, sample_ids, 2, TSK_SIMPLIFY_NO_FILTER_NODES, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n ret = tsk_treeseq_simplify(\n &ts, sample_ids, 1, TSK_SIMPLIFY_NO_FILTER_NODES, &simplified, node_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&simplified), 4);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_edges(&simplified), 0);\n for (j = 0; j < 4; j++) {\n CU_ASSERT_EQUAL(node_map[j], j);\n }\n tsk_treeseq_free(&simplified);\n\n ret = tsk_treeseq_simplify(&ts, sample_ids, 1,\n TSK_SIMPLIFY_NO_FILTER_NODES | TSK_SIMPLIFY_KEEP_INPUT_ROOTS\n | TSK_SIMPLIFY_KEEP_UNARY,\n &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&simplified), 4);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_edges(&simplified), 1);\n tsk_treeseq_free(&simplified);\n\n sample_ids[0] = 0;\n sample_ids[1] = 0;\n ret = tsk_treeseq_simplify(\n &ts, sample_ids, 2, TSK_SIMPLIFY_NO_FILTER_NODES, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n tsk_treeseq_free(&simplified);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_no_update_flags(void)\n{\n const char *nodes = \"0 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\";\n const char *edges = \"0 1 2 0,1\\n\";\n tsk_treeseq_t ts, simplified;\n tsk_id_t sample_ids[] = { 0, 1 };\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n\n /* We have a mixture of sample and non-samples in the input tables */\n ret = tsk_treeseq_simplify(\n &ts, sample_ids, 2, TSK_SIMPLIFY_NO_UPDATE_SAMPLE_FLAGS, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n ret = tsk_treeseq_simplify(&ts, sample_ids, 2,\n TSK_SIMPLIFY_NO_UPDATE_SAMPLE_FLAGS | TSK_SIMPLIFY_NO_FILTER_NODES, &simplified,\n NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, simplified.tables, 0));\n tsk_treeseq_free(&simplified);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_map_mutations(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\";\n const char *edges = \"0 1 2 0,1\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int32_t genotypes[] = { 0, 0 };\n tsk_size_t num_transitions;\n tsk_state_transition_t *transitions;\n int32_t ancestral_state;\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_tree_next(&t));\n\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 0);\n free(transitions);\n\n genotypes[0] = 1;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[0].node, 0);\n CU_ASSERT_EQUAL_FATAL(transitions[0].parent, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(transitions[0].state, 1);\n free(transitions);\n\n genotypes[0] = -1;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 0);\n free(transitions);\n\n /* Check the null tree */\n genotypes[0] = 1;\n CU_ASSERT_FALSE(tsk_tree_next(&t));\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[0].node, 0);\n CU_ASSERT_EQUAL_FATAL(transitions[0].parent, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(transitions[0].state, 1);\n free(transitions);\n\n /* Assign the ancestral_state */\n genotypes[0] = 1;\n genotypes[1] = 1;\n ancestral_state = 0;\n ret = tsk_tree_map_mutations(&t, genotypes, NULL, TSK_MM_FIXED_ANCESTRAL_STATE,\n &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 2);\n CU_ASSERT_EQUAL_FATAL(transitions[0].node, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[0].parent, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(transitions[0].state, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[1].node, 0);\n CU_ASSERT_EQUAL_FATAL(transitions[1].parent, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(transitions[1].state, 1);\n free(transitions);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_nonbinary_map_mutations(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\";\n const char *edges = \"0 1 4 0,1,2,3\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int32_t genotypes[] = { 0, 0, 0, 0 };\n tsk_size_t num_transitions;\n tsk_state_transition_t *transitions;\n int32_t ancestral_state;\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_tree_next(&t));\n\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 0);\n free(transitions);\n\n genotypes[0] = 1;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[0].node, 0);\n CU_ASSERT_EQUAL_FATAL(transitions[0].parent, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(transitions[0].state, 1);\n free(transitions);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_unary_map_mutations(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 1 0\\n\"\n \"0 2 0\";\n const char *edges = \"0 1 2 0\\n\"\n \"0 1 3 1\\n\"\n \"0 1 4 2,3\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int32_t genotypes[] = { 0, 0 };\n tsk_size_t num_transitions;\n tsk_state_transition_t *transitions;\n int32_t ancestral_state;\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_tree_next(&t));\n\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 0);\n free(transitions);\n\n genotypes[0] = 1;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[0].node, 2);\n CU_ASSERT_EQUAL_FATAL(transitions[0].parent, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(transitions[0].state, 1);\n free(transitions);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_non_sample_leaf_map_mutations(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 0 0\\n\"\n \"0 0 0\";\n const char *edges = \"0 1 2 0,1,3,4\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int32_t genotypes[] = { 0, 0 };\n tsk_size_t num_transitions;\n tsk_state_transition_t *transitions;\n int32_t ancestral_state;\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_tree_next(&t));\n\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 0);\n free(transitions);\n\n genotypes[0] = 1;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[0].node, 0);\n CU_ASSERT_EQUAL_FATAL(transitions[0].parent, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(transitions[0].state, 1);\n free(transitions);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_internal_sample_map_mutations(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 1 0\";\n const char *edges = \"0 1 2 0,1\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int32_t genotypes[] = { 0, 0, 0 };\n tsk_size_t num_transitions;\n tsk_state_transition_t *transitions;\n int32_t ancestral_state;\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_tree_next(&t));\n\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 0);\n free(transitions);\n\n genotypes[0] = 1;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[0].node, 0);\n CU_ASSERT_EQUAL_FATAL(transitions[0].parent, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(transitions[0].state, 1);\n free(transitions);\n\n genotypes[2] = 1;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 1);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[0].node, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[0].parent, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(transitions[0].state, 0);\n free(transitions);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_multiple_root_map_mutations(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 1 0\\n\";\n const char *edges = \"0 1 4 0,1\\n\"\n \"0 1 5 2,3\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int32_t genotypes[] = { 0, 0, 0, 0 };\n tsk_size_t num_transitions;\n tsk_state_transition_t *transitions;\n int32_t ancestral_state;\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_tree_next(&t));\n\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 0);\n free(transitions);\n\n genotypes[0] = 1;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[0].node, 0);\n CU_ASSERT_EQUAL_FATAL(transitions[0].parent, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(transitions[0].state, 1);\n free(transitions);\n\n genotypes[1] = 1;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[0].node, 4);\n CU_ASSERT_EQUAL_FATAL(transitions[0].parent, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(transitions[0].state, 1);\n free(transitions);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_chained_map_mutations(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 1 0\\n\"\n \"1 1 0\\n\"\n \"0 2 0\";\n const char *edges = \"0 1 2 0\\n\"\n \"0 1 3 1\\n\"\n \"0 1 4 2,3\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int32_t genotypes[] = { 0, 0, 0, 0 };\n tsk_size_t num_transitions;\n tsk_state_transition_t *transitions;\n int32_t ancestral_state;\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_tree_next(&t));\n\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 0);\n free(transitions);\n\n genotypes[2] = 1;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 2);\n CU_ASSERT_EQUAL_FATAL(transitions[0].node, 2);\n CU_ASSERT_EQUAL_FATAL(transitions[0].parent, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(transitions[0].state, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[1].node, 0);\n CU_ASSERT_EQUAL_FATAL(transitions[1].parent, 0);\n CU_ASSERT_EQUAL_FATAL(transitions[1].state, 0);\n free(transitions);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplest_mutation_edges(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 1 0\";\n const char *edges = \"0 1 1 0\\n\"\n \"1 2 2 0\\n\";\n const char *sites = \"0.5 0\\n\"\n \"1.5 0\\n\";\n const char *mutations = \"0 2 1\\n\"\n \"0 1 1\\n\"\n \"0 0 1\\n\"\n \"1 2 1\\n\"\n \"1 1 1\\n\"\n \"1 0 1\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t tree;\n /* We have mutations over roots, samples and just isolated nodes */\n tsk_id_t mutation_edges[] = { -1, -1, 0, -1, -1, 1 };\n tsk_size_t i, j, k, t;\n tsk_mutation_t mut;\n tsk_site_t site;\n int ret;\n\n tsk_treeseq_from_text(&ts, 2, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 6);\n\n for (j = 0; j < tsk_treeseq_get_num_mutations(&ts); j++) {\n ret = tsk_treeseq_get_mutation(&ts, (tsk_id_t) j, &mut);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(mut.edge, mutation_edges[j]);\n }\n\n ret = tsk_tree_init(&tree, &ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n i = 0;\n for (t = 0; t < 2; t++) {\n ret = tsk_tree_next(&tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n for (j = 0; j < tree.sites_length; j++) {\n site = tree.sites[j];\n for (k = 0; k < site.mutations_length; k++) {\n CU_ASSERT_EQUAL(site.mutations[k].edge, mutation_edges[i]);\n i++;\n }\n }\n }\n CU_ASSERT_EQUAL(i, 6);\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n}\n\n/*=======================================================\n * Single tree tests.\n *======================================================*/\n\nstatic void\ntest_single_tree_good_records(void)\n{\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 4);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 7);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n verify_edge_array_trees(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_nonbinary_tree_good_records(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 2 0\\n\"\n \"0 3 0\\n\";\n const char *edges = \"0 1 7 0,1,2,3\\n\"\n \"0 1 8 4,5\\n\"\n \"0 1 9 6,7,8\";\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 7);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 10);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n verify_edge_array_trees(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_bad_records(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_flags_t load_flags = TSK_TS_INIT_BUILD_INDEXES;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1;\n parse_nodes(single_tree_ex_nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 7);\n parse_edges(single_tree_ex_edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 6);\n\n /* Not sorted in time order */\n tables.nodes.time[5] = 0.5;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_EDGES_NOT_SORTED_PARENT_TIME);\n tsk_treeseq_free(&ts);\n tables.nodes.time[5] = 2.0;\n\n /* Left value greater than sequence right */\n tables.edges.left[2] = 2.0;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_EDGE_INTERVAL);\n tsk_treeseq_free(&ts);\n tables.edges.left[2] = 0.0;\n\n /* Non finite */\n tables.nodes.time[5] = INFINITY;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_TIME_NONFINITE);\n tsk_treeseq_free(&ts);\n tables.nodes.time[5] = 2.0;\n\n tables.nodes.time[5] = NAN;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_TIME_NONFINITE);\n tsk_treeseq_free(&ts);\n tables.nodes.time[5] = 2.0;\n\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, 0);\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_single_tree_good_mutations(void)\n{\n tsk_treeseq_t ts;\n tsk_size_t j;\n tsk_size_t num_sites = 3;\n tsk_size_t num_mutations = 7;\n tsk_site_t other_sites[num_sites];\n tsk_mutation_t other_mutations[num_mutations];\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 4);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 1.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 7);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), num_sites);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), num_mutations);\n\n for (j = 0; j < num_sites; j++) {\n ret = tsk_treeseq_get_site(&ts, (tsk_id_t) j, other_sites + j);\n CU_ASSERT_EQUAL(ret, 0);\n }\n for (j = 0; j < num_mutations; j++) {\n ret = tsk_treeseq_get_mutation(&ts, (tsk_id_t) j, other_mutations + j);\n CU_ASSERT_EQUAL(ret, 0);\n }\n CU_ASSERT_EQUAL(other_sites[0].position, 0.125);\n CU_ASSERT_NSTRING_EQUAL(other_sites[0].ancestral_state, \"0\", 1);\n CU_ASSERT_EQUAL(other_sites[1].position, 0.25);\n CU_ASSERT_NSTRING_EQUAL(other_sites[1].ancestral_state, \"0\", 1);\n CU_ASSERT_EQUAL(other_sites[2].position, 0.5);\n CU_ASSERT_NSTRING_EQUAL(other_sites[2].ancestral_state, \"0\", 1);\n\n CU_ASSERT_EQUAL(other_mutations[0].id, 0);\n CU_ASSERT_EQUAL(other_mutations[0].node, 2);\n CU_ASSERT_NSTRING_EQUAL(other_mutations[0].derived_state, \"1\", 1);\n CU_ASSERT_NSTRING_EQUAL(other_mutations[0].inherited_state, \"0\", 1);\n CU_ASSERT_EQUAL(other_mutations[1].id, 1);\n CU_ASSERT_EQUAL(other_mutations[1].node, 4);\n CU_ASSERT_NSTRING_EQUAL(other_mutations[1].derived_state, \"1\", 1);\n CU_ASSERT_NSTRING_EQUAL(other_mutations[1].inherited_state, \"0\", 1);\n CU_ASSERT_EQUAL(other_mutations[2].id, 2);\n CU_ASSERT_EQUAL(other_mutations[2].node, 0);\n CU_ASSERT_NSTRING_EQUAL(other_mutations[2].derived_state, \"0\", 1);\n CU_ASSERT_NSTRING_EQUAL(other_mutations[2].inherited_state, \"1\", 1);\n CU_ASSERT_EQUAL(other_mutations[3].id, 3);\n CU_ASSERT_EQUAL(other_mutations[3].node, 0);\n CU_ASSERT_NSTRING_EQUAL(other_mutations[3].derived_state, \"1\", 1);\n CU_ASSERT_NSTRING_EQUAL(other_mutations[3].inherited_state, \"0\", 1);\n CU_ASSERT_EQUAL(other_mutations[4].id, 4);\n CU_ASSERT_EQUAL(other_mutations[4].node, 1);\n CU_ASSERT_NSTRING_EQUAL(other_mutations[4].derived_state, \"1\", 1);\n CU_ASSERT_NSTRING_EQUAL(other_mutations[4].inherited_state, \"0\", 1);\n CU_ASSERT_EQUAL(other_mutations[5].id, 5);\n CU_ASSERT_EQUAL(other_mutations[5].node, 2);\n CU_ASSERT_NSTRING_EQUAL(other_mutations[5].derived_state, \"1\", 1);\n CU_ASSERT_NSTRING_EQUAL(other_mutations[5].inherited_state, \"0\", 1);\n CU_ASSERT_EQUAL(other_mutations[6].id, 6);\n CU_ASSERT_EQUAL(other_mutations[6].node, 3);\n CU_ASSERT_NSTRING_EQUAL(other_mutations[6].derived_state, \"1\", 1);\n CU_ASSERT_NSTRING_EQUAL(other_mutations[6].inherited_state, \"0\", 1);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_bad_mutations(void)\n{\n int ret = 0;\n const char *sites = \"0 0\\n\"\n \"0.1 0\\n\"\n \"0.2 0\\n\";\n const char *mutations = \"0 0 1 -1 0\\n\"\n \"1 1 1 -1 0\\n\"\n \"2 4 1 -1 1\\n\"\n \"2 1 0 2 0\\n\"\n \"2 1 1 3 0\\n\"\n \"2 2 1 -1 0\\n\";\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_flags_t load_flags = TSK_TS_INIT_BUILD_INDEXES;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1;\n parse_nodes(single_tree_ex_nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 7);\n parse_edges(single_tree_ex_edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 6);\n parse_sites(sites, &tables.sites);\n parse_mutations(mutations, &tables.mutations);\n CU_ASSERT_EQUAL_FATAL(tables.sites.num_rows, 3);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.num_rows, 6);\n tables.sequence_length = 1.0;\n\n /* Check to make sure we have legal mutations */\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 6);\n tsk_treeseq_free(&ts);\n\n /* negative coordinate */\n tables.sites.position[0] = -1.0;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_SITE_POSITION);\n tsk_treeseq_free(&ts);\n tables.sites.position[0] = 0.0;\n\n /* non finite coordinates */\n tables.sites.position[0] = NAN;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_SITE_POSITION);\n tsk_treeseq_free(&ts);\n tables.sites.position[0] = 0.0;\n\n tables.sites.position[0] = INFINITY;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_SITE_POSITION);\n tsk_treeseq_free(&ts);\n tables.sites.position[0] = 0.0;\n\n /* coordinate == sequence length */\n tables.sites.position[2] = 1.0;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_SITE_POSITION);\n tsk_treeseq_free(&ts);\n tables.sites.position[2] = 0.2;\n\n /* coordinate > sequence length */\n tables.sites.position[2] = 1.1;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_SITE_POSITION);\n tsk_treeseq_free(&ts);\n tables.sites.position[2] = 0.2;\n\n /* Duplicate positions */\n tables.sites.position[0] = 0.1;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_DUPLICATE_SITE_POSITION);\n tsk_treeseq_free(&ts);\n tables.sites.position[0] = 0.0;\n\n /* Unsorted positions */\n tables.sites.position[0] = 0.3;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_UNSORTED_SITES);\n tsk_treeseq_free(&ts);\n tables.sites.position[0] = 0.0;\n\n /* site < 0 */\n tables.mutations.site[0] = -2;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.mutations.site[0] = 0;\n\n /* site == num_sites */\n tables.mutations.site[0] = 3;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.mutations.site[0] = 0;\n\n /* node = NULL */\n tables.mutations.node[0] = TSK_NULL;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.mutations.node[0] = 0;\n\n /* node >= num_nodes */\n tables.mutations.node[0] = 7;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.mutations.node[0] = 0;\n\n /* parent < -1 */\n tables.mutations.parent[0] = -2;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.mutations.parent[0] = TSK_NULL;\n\n /* parent >= num_mutations */\n tables.mutations.parent[0] = 7;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n tsk_treeseq_free(&ts);\n tables.mutations.parent[0] = TSK_NULL;\n\n /* parent on a different site */\n tables.mutations.parent[1] = 0;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_MUTATION_PARENT_DIFFERENT_SITE);\n tsk_treeseq_free(&ts);\n tables.mutations.parent[1] = TSK_NULL;\n\n /* parent is the same mutation */\n tables.mutations.parent[0] = 0;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_MUTATION_PARENT_EQUAL);\n tsk_treeseq_free(&ts);\n tables.mutations.parent[0] = TSK_NULL;\n\n /* parent_id > mutation id */\n tables.mutations.parent[3] = 4;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_MUTATION_PARENT_AFTER_CHILD);\n tsk_treeseq_free(&ts);\n tables.mutations.parent[3] = 2;\n\n /* time < node time */\n tables.mutations.time[2] = 0;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_MUTATION_TIME_YOUNGER_THAN_NODE);\n tsk_treeseq_free(&ts);\n tables.mutations.time[2] = 1;\n\n /* time > parent mutation */\n tables.mutations.time[4] = 0.5;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_MUTATION_TIME_OLDER_THAN_PARENT_MUTATION);\n tsk_treeseq_free(&ts);\n tables.mutations.time[4] = 0;\n\n /* time > parent node */\n tables.mutations.time[0] = 1.5;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_MUTATION_TIME_OLDER_THAN_PARENT_NODE);\n tsk_treeseq_free(&ts);\n tables.mutations.time[0] = 0;\n\n /* Check to make sure we've maintained legal mutations */\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 6);\n tsk_treeseq_free(&ts);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_single_tree_iter(void)\n{\n int ret;\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 2 0\\n\"\n \"0 3 0\\n\";\n const char *edges = \"0 6 4 0,1\\n\"\n \"0 6 5 2,3\\n\"\n \"0 6 6 4,5\\n\";\n tsk_id_t parents[] = { 4, 4, 5, 5, 6, 6, TSK_NULL };\n tsk_treeseq_t ts;\n tsk_tree_t tree;\n tsk_id_t u, v, w;\n tsk_size_t num_samples;\n tsk_size_t num_nodes = 7;\n\n tsk_treeseq_from_text(&ts, 6, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n verify_edge_array_trees(&ts);\n ret = tsk_tree_init(&tree, &ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), num_nodes);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n CU_ASSERT_EQUAL(tree.num_children[4], 2);\n CU_ASSERT_EQUAL(tsk_tree_get_num_roots(&tree), 1);\n tsk_tree_print_state(&tree, _devnull);\n\n for (u = 0; u < (tsk_id_t) num_nodes; u++) {\n ret = tsk_tree_get_parent(&tree, u, &v);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(v, parents[u]);\n }\n ret = tsk_tree_get_num_samples(&tree, 0, &num_samples);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(num_samples, 1);\n ret = tsk_tree_get_num_samples(&tree, 4, &num_samples);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(num_samples, 2);\n ret = tsk_tree_get_num_samples(&tree, 6, &num_samples);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(num_samples, 4);\n ret = tsk_tree_get_mrca(&tree, 0, 1, &w);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(w, 4);\n ret = tsk_tree_get_mrca(&tree, 0, 2, &w);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(w, 6);\n\n ret = tsk_tree_next(&tree);\n CU_ASSERT_EQUAL(ret, 0);\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_nonbinary_tree_iter(void)\n{\n int ret;\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 2 0\\n\"\n \"0 3 0\\n\";\n const char *edges = \"0 1 7 0,1,2,3\\n\"\n \"0 1 8 4,5\\n\"\n \"0 1 9 6,7,8\\n\";\n tsk_id_t parents[] = { 7, 7, 7, 7, 8, 8, 9, 9, 9, TSK_NULL };\n tsk_treeseq_t ts;\n tsk_tree_t tree;\n tsk_id_t u, v, w;\n tsk_size_t num_samples;\n tsk_size_t num_nodes = 10;\n tsk_size_t total_samples = 7;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n verify_edge_array_trees(&ts);\n ret = tsk_tree_init(&tree, &ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), num_nodes);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n tsk_tree_print_state(&tree, _devnull);\n\n for (u = 0; u < (tsk_id_t) num_nodes; u++) {\n ret = tsk_tree_get_parent(&tree, u, &v);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(v, parents[u]);\n }\n for (u = 0; u < (tsk_id_t) total_samples; u++) {\n ret = tsk_tree_get_num_samples(&tree, u, &num_samples);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(num_samples, 1);\n CU_ASSERT_EQUAL(tree.left_child[u], TSK_NULL);\n }\n\n u = 7;\n ret = tsk_tree_get_num_samples(&tree, u, &num_samples);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(num_samples, 4);\n CU_ASSERT_EQUAL(tree.right_child[u], 3);\n CU_ASSERT_EQUAL(tree.left_sib[3], 2);\n CU_ASSERT_EQUAL(tree.left_sib[2], 1);\n CU_ASSERT_EQUAL(tree.left_sib[1], 0);\n CU_ASSERT_EQUAL(tree.left_sib[0], TSK_NULL);\n CU_ASSERT_EQUAL(tree.num_children[u], 4);\n\n u = 8;\n ret = tsk_tree_get_num_samples(&tree, u, &num_samples);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(num_samples, 2);\n CU_ASSERT_EQUAL(tree.right_child[u], 5);\n CU_ASSERT_EQUAL(tree.left_sib[5], 4);\n CU_ASSERT_EQUAL(tree.left_sib[4], TSK_NULL);\n CU_ASSERT_EQUAL(tree.num_children[u], 2);\n\n u = 9;\n ret = tsk_tree_get_num_samples(&tree, u, &num_samples);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(num_samples, 7);\n CU_ASSERT_EQUAL(tree.right_child[u], 8);\n CU_ASSERT_EQUAL(tree.left_sib[8], 7);\n CU_ASSERT_EQUAL(tree.left_sib[7], 6);\n CU_ASSERT_EQUAL(tree.left_sib[6], TSK_NULL);\n CU_ASSERT_EQUAL(tree.num_children[u], 3);\n\n CU_ASSERT_EQUAL(tsk_tree_get_num_roots(&tree), 1);\n CU_ASSERT_EQUAL(tsk_tree_get_left_root(&tree), 9);\n\n ret = tsk_tree_get_mrca(&tree, 0, 1, &w);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(w, 7);\n ret = tsk_tree_get_mrca(&tree, 0, 4, &w);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(w, 9);\n\n ret = tsk_tree_next(&tree);\n CU_ASSERT_EQUAL(ret, 0);\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_general_samples_iter(void)\n{\n int ret;\n const char *nodes = \"0 3 0\\n\"\n \"0 2 0\\n\"\n \"0 1 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\";\n const char *edges = \"0 6 2 3,4\\n\"\n \"0 6 1 5,6\\n\"\n \"0 6 0 1,2\\n\";\n tsk_id_t parents[] = { TSK_NULL, 0, 0, 2, 2, 1, 1 };\n const tsk_id_t *samples;\n tsk_treeseq_t ts;\n tsk_tree_t tree;\n tsk_id_t u, v, w;\n tsk_size_t num_samples;\n tsk_size_t num_nodes = 7;\n\n tsk_treeseq_from_text(&ts, 6, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n samples = tsk_treeseq_get_samples(&ts);\n CU_ASSERT_EQUAL(samples[0], 3);\n CU_ASSERT_EQUAL(samples[1], 4);\n CU_ASSERT_EQUAL(samples[2], 5);\n CU_ASSERT_EQUAL(samples[3], 6);\n verify_edge_array_trees(&ts);\n\n ret = tsk_tree_init(&tree, &ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), num_nodes);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n tsk_tree_print_state(&tree, _devnull);\n\n for (u = 0; u < (tsk_id_t) num_nodes; u++) {\n ret = tsk_tree_get_parent(&tree, u, &v);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(v, parents[u]);\n }\n ret = tsk_tree_get_num_samples(&tree, 3, &num_samples);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(num_samples, 1);\n ret = tsk_tree_get_num_samples(&tree, 2, &num_samples);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(num_samples, 2);\n ret = tsk_tree_get_num_samples(&tree, 0, &num_samples);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(num_samples, 4);\n ret = tsk_tree_get_mrca(&tree, 3, 4, &w);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(w, 2);\n ret = tsk_tree_get_mrca(&tree, 3, 6, &w);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(w, 0);\n\n ret = tsk_tree_next(&tree);\n CU_ASSERT_EQUAL(ret, 0);\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_iter_times(void)\n{\n int ret = 0;\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 2 0\\n\"\n \"1 3 0\\n\"\n \"0 1 0\\n\"\n \"0 4 0\\n\"\n \"0 5 0\\n\";\n const char *edges = \"0 6 4 0,1\\n\"\n \"0 6 5 2,3\\n\"\n \"0 6 6 4,5\\n\";\n tsk_id_t parents[] = { 4, 4, 5, 5, 6, 6, TSK_NULL };\n double times[] = { 0.0, 0.0, 2.0, 3.0, 1.0, 4.0, 5.0 };\n double t;\n tsk_treeseq_t ts;\n tsk_tree_t tree;\n tsk_id_t u, v;\n uint32_t num_nodes = 7;\n\n tsk_treeseq_from_text(&ts, 6, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&tree, &ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), num_nodes);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n tsk_tree_print_state(&tree, _devnull);\n\n for (u = 0; u < (tsk_id_t) num_nodes; u++) {\n ret = tsk_tree_get_parent(&tree, u, &v);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(v, parents[u]);\n ret = tsk_tree_get_time(&tree, u, &t);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(t, times[u]);\n }\n ret = tsk_tree_next(&tree);\n CU_ASSERT_EQUAL(ret, 0);\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_iter_depths(void)\n{\n int ret = 0;\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 2 0\\n\"\n \"0 3 0\\n\";\n const char *edges = \"0 6 4 0,1\\n\"\n \"0 6 5 2,3\\n\"\n \"0 6 6 4,5\\n\";\n int depths[] = { 2, 2, 2, 2, 1, 1, 0 };\n int depth;\n tsk_treeseq_t ts;\n tsk_tree_t tree;\n tsk_id_t u;\n uint32_t num_nodes = 7;\n\n tsk_treeseq_from_text(&ts, 6, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&tree, &ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), num_nodes);\n\n for (u = 0; u < (tsk_id_t) num_nodes; u++) {\n ret = tsk_tree_get_depth(&tree, u, &depth);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(depth, depths[u]);\n }\n\n ret = tsk_tree_get_depth(&tree, (tsk_id_t) num_nodes + 1, &depth);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_tree_get_depth(&tree, TSK_NULL, &depth);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n ret = tsk_tree_next(&tree);\n CU_ASSERT_EQUAL(ret, 0);\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_simplify(void)\n{\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_id_t samples[] = { 0, 1 };\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n verify_simplify(&ts);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_simplify(&tables, samples, 2, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tables.nodes.num_rows, 3);\n CU_ASSERT_EQUAL(tables.edges.num_rows, 2);\n\n /* Zero samples gives us the empty table collection */\n ret = tsk_table_collection_simplify(&tables, samples, 0, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tables.nodes.num_rows, 0);\n CU_ASSERT_EQUAL(tables.edges.num_rows, 0);\n\n /* Make sure we detect unsorted edges */\n ret = tsk_treeseq_copy_tables(&ts, &tables, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n unsort_edges(&tables.edges, 0);\n ret = tsk_table_collection_simplify(&tables, samples, 2, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGES_NOT_SORTED_CHILD);\n\n /* detect bad parents */\n ret = tsk_treeseq_copy_tables(&ts, &tables, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.edges.parent[0] = -1;\n ret = tsk_table_collection_simplify(&tables, samples, 2, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NULL_PARENT);\n\n /* detect bad children */\n ret = tsk_treeseq_copy_tables(&ts, &tables, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.edges.child[0] = -1;\n ret = tsk_table_collection_simplify(&tables, samples, 2, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NULL_CHILD);\n\n /* detect loops */\n ret = tsk_treeseq_copy_tables(&ts, &tables, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.edges.child[0] = tables.edges.parent[0];\n ret = tsk_table_collection_simplify(&tables, samples, 2, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_NODE_TIME_ORDERING);\n\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_single_tree_simplify_debug(void)\n{\n tsk_treeseq_t ts, simplified;\n tsk_id_t samples[] = { 0, 1 };\n int ret;\n FILE *tmp = fopen(_tmp_file_name, \"w\");\n\n CU_ASSERT_FATAL(tmp != NULL);\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n\n tsk_set_debug_stream(tmp);\n ret = tsk_treeseq_simplify(&ts, samples, 2, TSK_DEBUG, &simplified, NULL);\n tsk_set_debug_stream(stdout);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(ftell(tmp) > 0);\n\n fclose(tmp);\n tsk_treeseq_free(&ts);\n tsk_treeseq_free(&simplified);\n}\n\nstatic void\ntest_single_tree_simplify_keep_input_roots(void)\n{\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_id_t samples[] = { 0, 1 };\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n verify_simplify(&ts);\n ret = tsk_treeseq_copy_tables(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_simplify(\n &tables, samples, 2, TSK_SIMPLIFY_KEEP_INPUT_ROOTS, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tables.nodes.num_rows, 4);\n CU_ASSERT_EQUAL(tables.edges.num_rows, 3);\n CU_ASSERT_EQUAL(tables.sites.num_rows, 3);\n CU_ASSERT_EQUAL(tables.mutations.num_rows, 4);\n\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_single_tree_simplify_no_sample_nodes(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t t1, t2;\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_copy_tables(&ts, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* We zero out the sample column in t1, and run simplify. We should\n * get back the same table */\n\n tsk_memset(t1.nodes.flags, 0, sizeof(*t1.nodes.flags) * t1.nodes.num_rows);\n\n ret = tsk_table_collection_simplify(&t1, samples, 4, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n\n tsk_table_collection_free(&t1);\n tsk_table_collection_free(&t2);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_simplify_null_samples(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t t1, t2;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_copy_tables(&ts, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_simplify(&t1, NULL, 0, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n\n tsk_table_collection_free(&t1);\n tsk_table_collection_free(&t2);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_compute_mutation_parents(void)\n{\n int ret = 0;\n const char *sites = \"0 0\\n\"\n \"0.1 0\\n\"\n \"0.2 0\\n\";\n const char *mutations = \"0 0 1 -1\\n\"\n \"1 1 1 -1\\n\"\n \"2 4 1 -1\\n\"\n \"2 1 0 2 \\n\"\n \"2 1 1 3 \\n\"\n \"2 2 1 -1\\n\";\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1;\n parse_nodes(single_tree_ex_nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 7);\n parse_edges(single_tree_ex_edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 6);\n parse_sites(sites, &tables.sites);\n parse_mutations(mutations, &tables.mutations);\n CU_ASSERT_EQUAL_FATAL(tables.sites.num_rows, 3);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.num_rows, 6);\n tables.sequence_length = 1.0;\n\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Check to make sure we have legal mutations */\n ret = tsk_treeseq_init(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 6);\n\n /* Compute the mutation parents */\n verify_compute_mutation_parents(&ts);\n tsk_treeseq_free(&ts);\n\n /* Bad site reference */\n tables.mutations.site[0] = -1;\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n tables.mutations.site[0] = 0;\n\n /* Bad site reference */\n tables.mutations.site[0] = -1;\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n tables.mutations.site[0] = 0;\n\n /* mutation sites out of order */\n tables.mutations.site[0] = 2;\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_UNSORTED_MUTATIONS);\n tables.mutations.site[0] = 0;\n\n /* sites out of order */\n tables.sites.position[0] = 0.11;\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_UNSORTED_SITES);\n tables.sites.position[0] = 0;\n\n /* Bad node reference */\n tables.mutations.node[0] = -1;\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tables.mutations.node[0] = 0;\n\n /* Bad node reference */\n tables.mutations.node[0] = (tsk_id_t) tables.nodes.num_rows;\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tables.mutations.node[0] = 0;\n\n /* Mutations not ordered by tree */\n tables.mutations.node[2] = 1;\n tables.mutations.node[3] = 4;\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_MUTATION_PARENT_AFTER_CHILD);\n tables.mutations.node[2] = 4;\n tables.mutations.node[3] = 1;\n\n /* Need to reset the parent field here */\n tsk_memset(\n tables.mutations.parent, 0xff, tables.mutations.num_rows * sizeof(tsk_id_t));\n /* Mutations not ordered by site */\n tables.mutations.site[3] = 1;\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSORTED_MUTATIONS);\n tables.mutations.site[3] = 2;\n\n /* Check to make sure we still have legal mutations */\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_init(&ts, &tables, 0);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 6);\n tsk_treeseq_free(&ts);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_single_tree_compute_mutation_times(void)\n{\n int ret = 0;\n const char *sites = \"0 0\\n\"\n \"0.1 0\\n\"\n \"0.2 0\\n\"\n \"0.3 0\\n\";\n const char *mutations = \"0 0 1 -1 3\\n\"\n \"1 1 1 -1 3\\n\"\n \"2 4 1 -1 8\\n\"\n \"2 1 0 2 4\\n\"\n \"2 2 1 -1 4\\n\"\n \"2 1 1 3 2\\n\"\n \"3 6 1 -1 10\\n\";\n /* 6 */\n /* 6 */\n /* / \\ */\n /* / \\ */\n /* 2 \\ */\n /* / 5 */\n /* 4 / \\ */\n /* 0 1,3,4 5 \\ */\n /* 0 1 2 3 */\n\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1;\n parse_nodes(single_tree_ex_nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 7);\n tables.nodes.time[4] = 6;\n tables.nodes.time[5] = 8;\n tables.nodes.time[6] = 10;\n parse_edges(single_tree_ex_edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 6);\n parse_sites(sites, &tables.sites);\n parse_mutations(mutations, &tables.mutations);\n CU_ASSERT_EQUAL_FATAL(tables.sites.num_rows, 4);\n CU_ASSERT_EQUAL_FATAL(tables.mutations.num_rows, 7);\n tables.sequence_length = 1.0;\n\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n /* Check to make sure we have legal mutations */\n ret = tsk_treeseq_init(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 4);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 7);\n\n /* Compute the mutation times */\n verify_compute_mutation_times(&ts);\n\n /* Verify consistency of individuals */\n verify_individual_nodes(&ts);\n tsk_treeseq_free(&ts);\n\n /* Bad random param */\n ret = tsk_table_collection_compute_mutation_times(&tables, (double *) 1, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* Bad site reference */\n tables.mutations.site[0] = -1;\n ret = tsk_table_collection_compute_mutation_times(&tables, NULL, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n tables.mutations.site[0] = 0;\n\n /* Bad site reference */\n tables.mutations.site[0] = -1;\n ret = tsk_table_collection_compute_mutation_times(&tables, NULL, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n tables.mutations.site[0] = 0;\n\n /* mutation sites out of order */\n tables.mutations.site[0] = 2;\n ret = tsk_table_collection_compute_mutation_times(&tables, NULL, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_UNSORTED_MUTATIONS);\n tables.mutations.site[0] = 0;\n\n /* sites out of order */\n tables.sites.position[0] = 0.11;\n ret = tsk_table_collection_compute_mutation_times(&tables, NULL, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_UNSORTED_SITES);\n tables.sites.position[0] = 0;\n\n /* Bad node reference */\n tables.mutations.node[0] = -1;\n ret = tsk_table_collection_compute_mutation_times(&tables, NULL, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tables.mutations.node[0] = 0;\n\n /* Bad node reference */\n tables.mutations.node[0] = (tsk_id_t) tables.nodes.num_rows;\n ret = tsk_table_collection_compute_mutation_times(&tables, NULL, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tables.mutations.node[0] = 0;\n\n /* Mutations not ordered by site */\n tables.mutations.site[2] = 0;\n ret = tsk_table_collection_compute_mutation_times(&tables, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSORTED_MUTATIONS);\n tables.mutations.site[2] = 2;\n\n ret = tsk_treeseq_init(&ts, &tables, 0);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 4);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 7);\n tsk_treeseq_free(&ts);\n\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_single_tree_mutation_edges(void)\n{\n int ret = 0;\n tsk_size_t i, j, k;\n tsk_treeseq_t ts;\n tsk_tree_t tree;\n tsk_mutation_t mut;\n tsk_site_t site;\n tsk_id_t mutation_edges[] = { 2, 4, 0, 0, 1, 2, 3 };\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n\n for (j = 0; j < 7; j++) {\n ret = tsk_treeseq_get_mutation(&ts, (tsk_id_t) j, &mut);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(mut.edge, mutation_edges[j]);\n }\n\n ret = tsk_tree_init(&tree, &ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL(ret, TSK_TREE_OK);\n i = 0;\n for (j = 0; j < tree.sites_length; j++) {\n site = tree.sites[j];\n for (k = 0; k < site.mutations_length; k++) {\n CU_ASSERT_EQUAL(site.mutations[k].edge, mutation_edges[i]);\n i++;\n }\n }\n CU_ASSERT_EQUAL(i, 7);\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_is_descendant(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t tree;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&tree, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n CU_ASSERT_TRUE(tsk_tree_is_descendant(&tree, 0, 4));\n CU_ASSERT_TRUE(tsk_tree_is_descendant(&tree, 1, 4));\n CU_ASSERT_TRUE(tsk_tree_is_descendant(&tree, 0, 6));\n CU_ASSERT_TRUE(tsk_tree_is_descendant(&tree, 1, 6));\n CU_ASSERT_TRUE(tsk_tree_is_descendant(&tree, 4, 6));\n CU_ASSERT_TRUE(tsk_tree_is_descendant(&tree, 2, 5));\n CU_ASSERT_TRUE(tsk_tree_is_descendant(&tree, 3, 5));\n CU_ASSERT_TRUE(tsk_tree_is_descendant(&tree, 2, 6));\n CU_ASSERT_TRUE(tsk_tree_is_descendant(&tree, 3, 6));\n CU_ASSERT_TRUE(tsk_tree_is_descendant(&tree, 5, 6));\n /* Nodes are descendents of themselves. */\n CU_ASSERT_TRUE(tsk_tree_is_descendant(&tree, 0, 0));\n CU_ASSERT_TRUE(tsk_tree_is_descendant(&tree, 1, 1));\n\n CU_ASSERT_FALSE(tsk_tree_is_descendant(&tree, 0, 1));\n CU_ASSERT_FALSE(tsk_tree_is_descendant(&tree, 0, 2));\n CU_ASSERT_FALSE(tsk_tree_is_descendant(&tree, 0, 5));\n\n /* Out of bounds nodes always return false.*/\n CU_ASSERT_FALSE(tsk_tree_is_descendant(&tree, -1, 5));\n CU_ASSERT_FALSE(tsk_tree_is_descendant(&tree, 100, 5));\n CU_ASSERT_FALSE(tsk_tree_is_descendant(&tree, -1, -1));\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_total_branch_length(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t tree;\n double length;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&tree, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_total_branch_length(&tree, TSK_NULL, &length), 0);\n CU_ASSERT_EQUAL_FATAL(length, 9);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_total_branch_length(&tree, 7, &length), 0);\n CU_ASSERT_EQUAL_FATAL(length, 9);\n CU_ASSERT_EQUAL_FATAL(\n tsk_tree_get_total_branch_length(&tree, tree.virtual_root, &length), 0);\n CU_ASSERT_EQUAL_FATAL(length, 9);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_total_branch_length(&tree, 4, &length), 0);\n CU_ASSERT_EQUAL_FATAL(length, 2);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_total_branch_length(&tree, 0, &length), 0);\n CU_ASSERT_EQUAL_FATAL(length, 0);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_total_branch_length(&tree, 5, &length), 0);\n CU_ASSERT_EQUAL_FATAL(length, 4);\n\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_total_branch_length(&tree, -2, &length),\n TSK_ERR_NODE_OUT_OF_BOUNDS);\n CU_ASSERT_EQUAL_FATAL(\n tsk_tree_get_total_branch_length(&tree, 8, &length), TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_num_lineages(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t tree;\n tsk_size_t num_lineages;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&tree, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n CU_ASSERT_EQUAL_FATAL(tsk_tree_num_lineages(&tree, 0, &num_lineages), 0);\n CU_ASSERT_EQUAL_FATAL(num_lineages, 4);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_num_lineages(&tree, -1, &num_lineages), 0);\n CU_ASSERT_EQUAL_FATAL(num_lineages, 0);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_num_lineages(&tree, 1, &num_lineages), 0);\n CU_ASSERT_EQUAL_FATAL(num_lineages, 3);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_num_lineages(&tree, 2, &num_lineages), 0);\n CU_ASSERT_EQUAL_FATAL(num_lineages, 2);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_num_lineages(&tree, 2.999, &num_lineages), 0);\n CU_ASSERT_EQUAL_FATAL(num_lineages, 2);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_num_lineages(&tree, 3, &num_lineages), 0);\n CU_ASSERT_EQUAL_FATAL(num_lineages, 0);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_num_lineages(&tree, 300, &num_lineages), 0);\n CU_ASSERT_EQUAL_FATAL(num_lineages, 0);\n\n CU_ASSERT_EQUAL_FATAL(\n tsk_tree_num_lineages(&tree, INFINITY, &num_lineages), TSK_ERR_TIME_NONFINITE);\n CU_ASSERT_EQUAL_FATAL(\n tsk_tree_num_lineages(&tree, NAN, &num_lineages), TSK_ERR_TIME_NONFINITE);\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_map_mutations(void)\n{\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int32_t genotypes[] = { 0, 1, 1, 1 };\n int ret = 0;\n tsk_size_t num_transitions;\n tsk_state_transition_t *transitions;\n int32_t ancestral_state, j;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 4);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_tree_next(&t));\n\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 1);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[0].node, 0);\n CU_ASSERT_EQUAL_FATAL(transitions[0].parent, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(transitions[0].state, 0);\n free(transitions);\n\n genotypes[0] = 1;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 1);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 0);\n free(transitions);\n\n genotypes[0] = 0;\n genotypes[1] = 0;\n genotypes[2] = 0;\n genotypes[3] = 0;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 0);\n free(transitions);\n\n for (j = 1; j < 64; j++) {\n genotypes[0] = j;\n genotypes[1] = 0;\n genotypes[2] = 0;\n genotypes[3] = 0;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[0].node, 0);\n CU_ASSERT_EQUAL_FATAL(transitions[0].parent, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(transitions[0].state, j);\n free(transitions);\n }\n\n genotypes[0] = 2;\n genotypes[1] = 1;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 2);\n CU_ASSERT_EQUAL_FATAL(transitions[0].node, 4);\n CU_ASSERT_EQUAL_FATAL(transitions[0].parent, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(transitions[0].state, 1);\n CU_ASSERT_EQUAL_FATAL(transitions[1].node, 0);\n CU_ASSERT_EQUAL_FATAL(transitions[1].parent, 0);\n CU_ASSERT_EQUAL_FATAL(transitions[1].state, 2);\n free(transitions);\n\n genotypes[0] = 1;\n genotypes[1] = 2;\n genotypes[2] = 3;\n genotypes[3] = 4;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 3);\n free(transitions);\n\n ancestral_state = 5;\n ret = tsk_tree_map_mutations(&t, genotypes, NULL, TSK_MM_FIXED_ANCESTRAL_STATE,\n &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 4);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 5);\n free(transitions);\n\n ancestral_state = -1;\n ret = tsk_tree_map_mutations(&t, genotypes, NULL, TSK_MM_FIXED_ANCESTRAL_STATE,\n &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_ANCESTRAL_STATE);\n\n ancestral_state = 64;\n ret = tsk_tree_map_mutations(&t, genotypes, NULL, TSK_MM_FIXED_ANCESTRAL_STATE,\n &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_ANCESTRAL_STATE);\n\n genotypes[0] = 64;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_GENOTYPE);\n\n genotypes[0] = -2;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_GENOTYPE);\n\n genotypes[0] = -1;\n genotypes[1] = -1;\n genotypes[2] = -1;\n genotypes[3] = -1;\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_GENOTYPES_ALL_MISSING);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_single_tree_map_mutations_internal_samples(void)\n{\n /* Example derived from test case provoking a segfault */\n const char *nodes = \"0 0.00000000000000 0\\n\"\n \"0 0.00000000000000 0\\n\"\n \"1 0.00000000000000 0\\n\"\n \"1 0.00000000000000 0\\n\"\n \"1 0.00000000000000 0\\n\"\n \"0 0.10792116530237 0\\n\"\n \"1 1.00674711128465 0\\n\"\n \"1 1.24675560985525 0\\n\"\n \"0 1.78536352520779 0\\n\";\n const char *edges = \"0.00000000 1.00000000 5 0\\n\"\n \"0.00000000 1.00000000 5 2\\n\"\n \"0.00000000 1.00000000 6 4\\n\"\n \"0.00000000 1.00000000 6 5\\n\"\n \"0.00000000 1.00000000 7 1\\n\"\n \"0.00000000 1.00000000 7 3\\n\"\n \"0.00000000 1.00000000 8 6\\n\"\n \"0.00000000 1.00000000 8 7\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int32_t genotypes[] = { 0, 2, 2, 1, 0 };\n int ret = 0;\n tsk_size_t num_transitions;\n tsk_state_transition_t *transitions;\n int32_t ancestral_state;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 5);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_tree_next(&t));\n\n ret = tsk_tree_map_mutations(\n &t, genotypes, NULL, 0, &ancestral_state, &num_transitions, &transitions);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ancestral_state, 0);\n CU_ASSERT_EQUAL_FATAL(num_transitions, 4);\n free(transitions);\n\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n}\n\nstatic void\ntest_single_tree_tracked_samples(void)\n{\n tsk_treeseq_t ts;\n tsk_tree_t tree;\n tsk_id_t samples[] = { 0, 1 };\n tsk_size_t n;\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL,\n single_tree_ex_sites, single_tree_ex_mutations, NULL, NULL, 0);\n\n ret = tsk_tree_init(&tree, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_tree_set_tracked_samples(&tree, 2, samples);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_get_num_tracked_samples(&tree, 0, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 1);\n ret = tsk_tree_get_num_tracked_samples(&tree, 4, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 0);\n ret = tsk_tree_get_num_tracked_samples(&tree, tree.virtual_root, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 2);\n\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n ret = tsk_tree_get_num_tracked_samples(&tree, 0, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 1);\n ret = tsk_tree_get_num_tracked_samples(&tree, 4, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 2);\n ret = tsk_tree_get_num_tracked_samples(&tree, 5, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 0);\n ret = tsk_tree_get_num_tracked_samples(&tree, 6, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 2);\n ret = tsk_tree_get_num_tracked_samples(&tree, tree.virtual_root, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 2);\n\n ret = tsk_tree_next(&tree);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_get_num_tracked_samples(&tree, 0, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 1);\n ret = tsk_tree_get_num_tracked_samples(&tree, 4, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 0);\n ret = tsk_tree_get_num_tracked_samples(&tree, tree.virtual_root, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 2);\n\n ret = tsk_tree_next(&tree);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n ret = tsk_tree_get_num_tracked_samples(&tree, 0, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 1);\n ret = tsk_tree_get_num_tracked_samples(&tree, 4, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 2);\n ret = tsk_tree_get_num_tracked_samples(&tree, tree.virtual_root, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 2);\n\n ret = tsk_tree_set_tracked_samples(&tree, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_get_num_tracked_samples(&tree, 0, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 0);\n ret = tsk_tree_get_num_tracked_samples(&tree, tree.virtual_root, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 0);\n\n tsk_treeseq_free(&ts);\n tsk_tree_free(&tree);\n}\n\nstatic void\ntest_single_tree_tree_pos(void)\n{\n tsk_treeseq_t ts;\n tsk_tree_position_t tree_pos;\n bool valid;\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n\n ret = tsk_tree_position_init(&tree_pos, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n valid = tsk_tree_position_next(&tree_pos);\n CU_ASSERT_FATAL(valid);\n\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.left, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.right, 1);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.start, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.stop, 6);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.order, ts.tables->indexes.edge_insertion_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.start, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.stop, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.order, ts.tables->indexes.edge_removal_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.direction, TSK_DIR_FORWARD);\n\n valid = tsk_tree_position_next(&tree_pos);\n CU_ASSERT_FATAL(!valid);\n\n tsk_tree_position_print_state(&tree_pos, _devnull);\n\n CU_ASSERT_EQUAL_FATAL(tree_pos.index, -1);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.start, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.stop, 6);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.order, ts.tables->indexes.edge_removal_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.direction, TSK_DIR_FORWARD);\n\n valid = tsk_tree_position_prev(&tree_pos);\n CU_ASSERT_FATAL(valid);\n\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.left, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.right, 1);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.start, 5);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.stop, -1);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.order, ts.tables->indexes.edge_removal_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.start, 5);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.stop, 5);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.order, ts.tables->indexes.edge_insertion_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.direction, TSK_DIR_REVERSE);\n\n valid = tsk_tree_position_prev(&tree_pos);\n CU_ASSERT_FATAL(!valid);\n\n CU_ASSERT_EQUAL_FATAL(tree_pos.index, -1);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.start, 5);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.stop, -1);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.order, ts.tables->indexes.edge_insertion_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.direction, TSK_DIR_REVERSE);\n\n ret = tsk_tree_position_seek_forward(&tree_pos, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.left, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.right, 1);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.start, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.stop, 6);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.order, ts.tables->indexes.edge_insertion_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.start, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.stop, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.order, ts.tables->indexes.edge_removal_order)\n CU_ASSERT_EQUAL_FATAL(tree_pos.direction, TSK_DIR_FORWARD);\n\n valid = tsk_tree_position_next(&tree_pos);\n CU_ASSERT_FATAL(!valid);\n\n CU_ASSERT_EQUAL_FATAL(tree_pos.index, -1);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.start, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.stop, 6);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.order, ts.tables->indexes.edge_removal_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.direction, TSK_DIR_FORWARD);\n\n ret = tsk_tree_position_seek_backward(&tree_pos, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.left, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.right, 1);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.start, 5);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.stop, -1);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.order, ts.tables->indexes.edge_removal_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.start, 5);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.stop, 5);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.order, ts.tables->indexes.edge_insertion_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.direction, TSK_DIR_REVERSE);\n\n tsk_tree_position_free(&tree_pos);\n tsk_treeseq_free(&ts);\n}\n\n/*=======================================================\n * Multi tree tests.\n *======================================================*/\n\nstatic void\ntest_simple_multi_tree(void)\n{\n // clang-format off\n tsk_id_t parents[] = {\n 6, 5, 8, 5, TSK_NULL, 6, 8, TSK_NULL, TSK_NULL,\n 6, 5, 4, 4, 5, 6, TSK_NULL, TSK_NULL, TSK_NULL,\n 7, 5, 4, 4, 5, 7, TSK_NULL, TSK_NULL, TSK_NULL,\n };\n // clang-format on\n uint32_t num_trees = 3;\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n verify_trees(&ts, num_trees, parents);\n verify_edge_array_trees(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_multi_tree_direction_switching_tree_pos(void)\n{\n tsk_treeseq_t ts;\n tsk_tree_position_t tree_pos;\n bool valid;\n int ret = 0;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n ret = tsk_tree_position_init(&tree_pos, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n valid = tsk_tree_position_next(&tree_pos);\n CU_ASSERT_FATAL(valid);\n\n CU_ASSERT_EQUAL_FATAL(tree_pos.index, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.left, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.right, 2);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.start, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.stop, 6);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.order, ts.tables->indexes.edge_insertion_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.start, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.stop, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.order, ts.tables->indexes.edge_removal_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.direction, TSK_DIR_FORWARD);\n\n valid = tsk_tree_position_prev(&tree_pos);\n CU_ASSERT_FATAL(!valid);\n\n CU_ASSERT_EQUAL_FATAL(tree_pos.index, -1);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.start, 5);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.stop, -1);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.order, ts.tables->indexes.edge_insertion_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.direction, TSK_DIR_REVERSE);\n\n valid = tsk_tree_position_prev(&tree_pos);\n CU_ASSERT_FATAL(valid);\n\n CU_ASSERT_EQUAL_FATAL(tree_pos.index, 2);\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.left, 7);\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.right, 10);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.start, 10);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.stop, 4);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.order, ts.tables->indexes.edge_removal_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.start, 10);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.stop, 10);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.order, ts.tables->indexes.edge_insertion_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.direction, TSK_DIR_REVERSE);\n\n valid = tsk_tree_position_next(&tree_pos);\n CU_ASSERT_FATAL(!valid);\n\n CU_ASSERT_EQUAL_FATAL(tree_pos.index, -1);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.start, 5);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.stop, 11);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.order, ts.tables->indexes.edge_removal_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.direction, TSK_DIR_FORWARD);\n\n ret = tsk_tree_position_seek_forward(&tree_pos, 2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.left, 7);\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.right, 10);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.start, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.stop, 11);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.order, ts.tables->indexes.edge_insertion_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.start, 5);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.stop, 5);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.order, ts.tables->indexes.edge_removal_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.direction, TSK_DIR_FORWARD);\n\n ret = tsk_tree_position_seek_backward(&tree_pos, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(tree_pos.index, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.left, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.right, 2);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.start, 4);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.stop, -1);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.order, ts.tables->indexes.edge_removal_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.start, 10);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.stop, 5);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.order, ts.tables->indexes.edge_insertion_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.direction, TSK_DIR_REVERSE);\n\n ret = tsk_tree_position_seek_forward(&tree_pos, 2);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(tree_pos.index, 2);\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.left, 7);\n CU_ASSERT_EQUAL_FATAL(tree_pos.interval.right, 10);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.start, 6);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.stop, 11);\n CU_ASSERT_EQUAL_FATAL(tree_pos.in.order, ts.tables->indexes.edge_insertion_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.start, 0);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.stop, 5);\n CU_ASSERT_EQUAL_FATAL(tree_pos.out.order, ts.tables->indexes.edge_removal_order);\n CU_ASSERT_EQUAL_FATAL(tree_pos.direction, TSK_DIR_FORWARD);\n\n tsk_tree_position_free(&tree_pos);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_unary_multi_tree(void)\n{\n // clang-format off\n tsk_id_t parents[] = {\n 6, 5, 7, 5, TSK_NULL, 6, 8, 8, TSK_NULL, 5,\n 6, 5, 4, 4, 5, 6, 8, TSK_NULL, TSK_NULL, 5,\n 7, 5, 4, 4, 5, 7, TSK_NULL, TSK_NULL, TSK_NULL, 5,\n };\n // clang-format on\n tsk_treeseq_t ts;\n uint32_t num_trees = 3;\n\n tsk_treeseq_from_text(&ts, 10, unary_ex_nodes, unary_ex_edges, NULL, unary_ex_sites,\n unary_ex_mutations, NULL, NULL, 0);\n verify_trees(&ts, num_trees, parents);\n verify_edge_array_trees(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_internal_sample_multi_tree(void)\n{\n // clang-format off\n tsk_id_t parents[] = {\n 7, 5, 4, 4, 5, 7, TSK_NULL, TSK_NULL, TSK_NULL,\n 4, 5, 4, 8, 5, 8, TSK_NULL, TSK_NULL, TSK_NULL,\n 6, 5, 4, 4, 5, 6, TSK_NULL, TSK_NULL, TSK_NULL,\n };\n // clang-format on\n tsk_treeseq_t ts;\n uint32_t num_trees = 3;\n\n tsk_treeseq_from_text(&ts, 10, internal_sample_ex_nodes, internal_sample_ex_edges,\n NULL, internal_sample_ex_sites, internal_sample_ex_mutations, NULL, NULL, 0);\n verify_trees(&ts, num_trees, parents);\n verify_edge_array_trees(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_internal_sample_simplified_multi_tree(void)\n{\n int ret;\n tsk_treeseq_t ts, simplified;\n tsk_id_t samples[] = { 2, 3, 5 };\n tsk_id_t node_map[9];\n tsk_id_t z = TSK_NULL;\n // clang-format off\n tsk_id_t parents[] = {\n /* 0 1 2 3 4 */\n 3, 3, z, 2, z,\n 2, 4, 4, z, z,\n 3, 3, z, 2, z,\n };\n // clang-format on\n uint32_t num_trees = 3;\n\n tsk_treeseq_from_text(&ts, 10, internal_sample_ex_nodes, internal_sample_ex_edges,\n NULL, internal_sample_ex_sites, internal_sample_ex_mutations, NULL, NULL, 0);\n ret = tsk_treeseq_simplify(&ts, samples, 3, 0, &simplified, node_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(node_map[2], 0);\n CU_ASSERT_EQUAL(node_map[3], 1);\n CU_ASSERT_EQUAL(node_map[5], 2);\n\n verify_trees(&simplified, num_trees, parents);\n verify_edge_array_trees(&ts);\n tsk_treeseq_free(&simplified);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_nonbinary_multi_tree(void)\n{\n /* We make one mutation for each tree */\n // clang-format off\n tsk_id_t parents[] = {\n 8, 8, 8, 8, 10, 10, 9, 10, 9, 12, 12, TSK_NULL, TSK_NULL,\n 8, 8, 8, 8, 10, 11, 9, 10, 9, 11, 12, 12, TSK_NULL,\n };\n // clang-format on\n\n tsk_treeseq_t ts;\n uint32_t num_trees = 2;\n\n tsk_treeseq_from_text(&ts, 100, nonbinary_ex_nodes, nonbinary_ex_edges, NULL,\n nonbinary_ex_sites, nonbinary_ex_mutations, NULL, NULL, 0);\n verify_trees(&ts, num_trees, parents);\n verify_edge_array_trees(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_simplify_keep_input_roots_multi_tree(void)\n{\n\n /*\n 0.25┊ 8 ┊ ┊ ┊\n ┊ ┏━┻━┓ ┊ ┊ ┊\n 0.20┊ ┃ ┃ ┊ ┊ 7 ┊\n ┊ ┃ ┃ ┊ ┊ ┏━┻━┓ ┊\n 0.17┊ 6 ┃ ┊ 6 ┊ ┃ ┃ ┊\n ┊ ┏━┻┓ ┃ ┊ ┏━┻━┓ ┊ ┃ ┃ ┊\n 0.09┊ ┃ 5 ┃ ┊ ┃ 5 ┊ ┃ 5 ┊\n ┊ ┃ ┏┻┓ ┃ ┊ ┃ ┏━┻┓ ┊ ┃ ┏━┻┓ ┊\n 0.07┊ ┃ ┃ ┃ ┃ ┊ ┃ ┃ 4 ┊ ┃ ┃ 4 ┊\n ┊ ┃ ┃ ┃ ┃ ┊ ┃ ┃ ┏┻┓ ┊ ┃ ┃ ┏┻┓ ┊\n 0.00┊ 0 1 3 2 ┊ 0 1 2 3 ┊ 0 1 2 3 ┊\n 0.00 2.00 7.00 10.00\n\n Simplifies to\n\n 0.25┊ 4 ┊ ┊ ┊\n ┊ ┃ ┊ ┊ ┊\n 0.20┊ ┃ ┊ ┊ 3 ┊\n ┊ ┃ ┊ ┊ ┏┻┓ ┊\n 0.17┊ 2 ┊ 2 ┊ ┃ ┃ ┊\n ┊ ┏┻┓ ┊ ┏┻┓ ┊ ┃ ┃ ┊\n 0.00┊ 0 1 ┊ 0 1 ┊ 0 1 ┊\n 0.00 2.00 7.00 10.00\n\n */\n int ret = 0;\n // clang-format off\n tsk_id_t parents[] = {\n 2, 2, 4, -1, -1,\n 2, 2, -1, -1, -1,\n 3, 3, -1, -1, -1,\n };\n // clang-format on\n uint32_t num_trees = 3;\n\n tsk_id_t samples[] = { 0, 3 };\n tsk_treeseq_t ts, simplified;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n ret = tsk_treeseq_simplify(\n &ts, samples, 2, TSK_SIMPLIFY_KEEP_INPUT_ROOTS, &simplified, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n verify_trees(&simplified, num_trees, parents);\n verify_edge_array_trees(&ts);\n\n tsk_treeseq_free(&ts);\n tsk_treeseq_free(&simplified);\n}\n\nstatic void\ntest_left_to_right_multi_tree(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 0.090 0\\n\"\n \"0 0.170 0\\n\"\n \"0 0.253 0\\n\"\n \"0 0.071 0\\n\"\n \"0 0.202 0\\n\";\n const char *edges = \"2 10 7 2,3\\n\"\n \"0 2 4 1\\n\"\n \"2 10 4 1\\n\"\n \"0 2 4 3\\n\"\n \"2 10 4 7\\n\"\n \"0 7 5 0,4\\n\"\n \"7 10 8 0,4\\n\"\n \"0 2 6 2,5\\n\";\n const char *sites = \"1 0\\n\"\n \"4.5 0\\n\"\n \"8.5 0\\n\";\n const char *mutations = \"0 2 1\\n\"\n \"1 0 1\\n\"\n \"2 4 1\\n\";\n\n // clang-format off\n tsk_id_t parents[] = {\n 5, 4, 6, 4, 5, 6, TSK_NULL, TSK_NULL, TSK_NULL,\n 5, 4, 7, 7, 5, TSK_NULL, TSK_NULL, 4, TSK_NULL,\n 8, 4, 7, 7, 8, TSK_NULL, TSK_NULL, 4, TSK_NULL,\n };\n // clang-format on\n tsk_treeseq_t ts;\n uint32_t num_trees = 3;\n\n tsk_treeseq_from_text(&ts, 10, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n verify_trees(&ts, num_trees, parents);\n verify_tree_next_prev(&ts);\n verify_edge_array_trees(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_gappy_multi_tree(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 0.090 0\\n\"\n \"0 0.170 0\\n\"\n \"0 0.253 0\\n\"\n \"0 0.071 0\\n\"\n \"0 0.202 0\\n\";\n const char *edges = \"2 7 7 2\\n\"\n \"8 10 7 2\\n\"\n \"2 7 7 3\\n\"\n \"8 10 7 3\\n\"\n \"1 2 4 1\\n\"\n \"2 7 4 1\\n\"\n \"8 10 4 1\\n\"\n \"1 2 4 3\\n\"\n \"2 7 4 7\\n\"\n \"8 10 4 7\\n\"\n \"1 7 5 0,4\\n\"\n \"8 10 8 0,4\\n\"\n \"1 2 6 2,5\\n\";\n tsk_id_t z = TSK_NULL;\n // clang-format off\n tsk_id_t parents[] = {\n z, z, z, z, z, z, z, z, z,\n 5, 4, 6, 4, 5, 6, z, z, z,\n 5, 4, 7, 7, 5, z, z, 4, z,\n z, z, z, z, z, z, z, z, z,\n 8, 4, 7, 7, 8, z, z, 4, z,\n z, z, z, z, z, z, z, z, z,\n };\n // clang-format on\n tsk_treeseq_t ts;\n uint32_t num_trees = 6;\n\n tsk_treeseq_from_text(&ts, 12, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n verify_trees(&ts, num_trees, parents);\n verify_tree_next_prev(&ts);\n verify_edge_array_trees(&ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_tsk_treeseq_bad_records(void)\n{\n int ret = 0;\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n uint32_t num_trees = 3;\n // clang-format off\n tsk_id_t parents[] = {\n 6, 5, 8, 5, TSK_NULL, 6, 8, TSK_NULL, TSK_NULL,\n 6, 5, 4, 4, 5, 6, TSK_NULL, TSK_NULL, TSK_NULL,\n 7, 5, 4, 4, 5, 7, TSK_NULL, TSK_NULL, TSK_NULL,\n };\n // clang-format on\n tsk_flags_t load_flags = TSK_TS_INIT_BUILD_INDEXES;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 10;\n parse_nodes(paper_ex_nodes, &tables.nodes);\n parse_edges(paper_ex_edges, &tables.edges);\n parse_individuals(paper_ex_individuals, &tables.individuals);\n\n /* Make sure we have a good set of records */\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ts.num_trees, 3);\n verify_trees(&ts, num_trees, parents);\n tsk_treeseq_free(&ts);\n\n /* Left value greater than right */\n tables.edges.left[0] = 10.0;\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_EDGE_INTERVAL);\n tsk_treeseq_free(&ts);\n tables.edges.left[0] = 2.0;\n\n ret = tsk_treeseq_init(&ts, &tables, load_flags);\n CU_ASSERT_EQUAL(ret, 0);\n verify_trees(&ts, num_trees, parents);\n tsk_treeseq_free(&ts);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_convenience_arrays_multi_tree(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t t;\n\n tsk_treeseq_from_text(\n &ts, 10, unary_ex_nodes, unary_ex_edges, NULL, NULL, NULL, NULL, NULL, 0);\n verify_edge_array_trees(&ts);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_tree_next(&t));\n CU_ASSERT_EQUAL(t.num_children[8], 2);\n\n CU_ASSERT_TRUE(tsk_tree_next(&t));\n CU_ASSERT_EQUAL(t.num_children[8], 1);\n\n CU_ASSERT_TRUE(tsk_tree_next(&t));\n CU_ASSERT_EQUAL(t.num_children[8], 0);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_multiroot_mrca(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t tree;\n tsk_id_t mrca;\n\n tsk_treeseq_from_text(&ts, 10, multiroot_ex_nodes, multiroot_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&tree, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&tree);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_mrca(&tree, 0, 0, &mrca), 0);\n CU_ASSERT_EQUAL(mrca, 0);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_mrca(&tree, 0, 1, &mrca), 0);\n CU_ASSERT_EQUAL(mrca, 10);\n /* MRCA of two nodes in different subtrees is TSK_NULL */\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_mrca(&tree, 0, 2, &mrca), 0);\n CU_ASSERT_EQUAL(mrca, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_mrca(&tree, 2, 0, &mrca), 0);\n CU_ASSERT_EQUAL(mrca, TSK_NULL);\n\n tsk_tree_free(&tree);\n tsk_treeseq_free(&ts);\n}\n\n/*=======================================================\n * Sample sets\n *======================================================*/\n\nstatic void\ntest_simple_sample_sets(void)\n{\n // clang-format off\n sample_count_test_t tests[] = {\n {0, 0, 1}, {0, 5, 2}, {0, 6, 3},\n {1, 4, 2}, {1, 5, 3}, {1, 6, 4}};\n // clang-format on\n uint32_t num_tests = 6;\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, NULL, NULL,\n paper_ex_individuals, NULL, 0);\n verify_sample_counts(&ts, num_tests, tests, 0);\n verify_sample_counts(&ts, num_tests, tests, TSK_SEEK_SKIP);\n verify_sample_sets(&ts);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_nonbinary_sample_sets(void)\n{\n // clang-format off\n sample_count_test_t tests[] = {\n {0, 0, 1}, {0, 8, 4}, {0, 9, 5}, {0, 10, 3}, {0, 12, 8},\n {1, 5, 1}, {1, 8, 4}, {1, 9, 5}, {0, 10, 2}, {0, 11, 1}};\n // clang-format on\n uint32_t num_tests = 8;\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 100, nonbinary_ex_nodes, nonbinary_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n verify_sample_counts(&ts, num_tests, tests, 0);\n verify_sample_counts(&ts, num_tests, tests, TSK_SEEK_SKIP);\n verify_sample_sets(&ts);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_internal_sample_sample_sets(void)\n{\n // clang-format off\n sample_count_test_t tests[] = {\n {0, 0, 1}, {0, 5, 4}, {0, 4, 2}, {0, 7, 5},\n {1, 4, 2}, {1, 5, 4}, {1, 8, 5},\n {2, 5, 4}, {2, 6, 5}};\n // clang-format on\n uint32_t num_tests = 9;\n tsk_treeseq_t ts;\n\n tsk_treeseq_from_text(&ts, 10, internal_sample_ex_nodes, internal_sample_ex_edges,\n NULL, NULL, NULL, NULL, NULL, 0);\n verify_sample_counts(&ts, num_tests, tests, 0);\n verify_sample_counts(&ts, num_tests, tests, TSK_SEEK_SKIP);\n verify_sample_sets(&ts);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_non_sample_leaf_sample_lists(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"0 0 0\\n\"\n \"1 2 0\\n\";\n const char *edges = \"0 1 2 0,1\\n\";\n const tsk_id_t left_sample[3] = { 0, -1, 1 };\n const tsk_id_t right_sample[3] = { 0, -1, 0 };\n const tsk_id_t next_sample[2] = { -1, 0 };\n const tsk_id_t samples[2] = { 0, 2 };\n const tsk_id_t sample_index_map[3] = { 0, -1, 1 };\n tsk_treeseq_t ts;\n tsk_tree_t t;\n tsk_id_t i;\n int ret;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n\n ret = tsk_tree_init(&t, &ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n for (i = 0; i < 3; i++) {\n CU_ASSERT_EQUAL_FATAL(left_sample[i], t.left_sample[i]);\n CU_ASSERT_EQUAL_FATAL(right_sample[i], t.right_sample[i]);\n CU_ASSERT_EQUAL_FATAL(sample_index_map[i], ts.sample_index_map[i]);\n }\n for (i = 0; i < 2; i++) {\n CU_ASSERT_EQUAL_FATAL(next_sample[i], t.next_sample[i]);\n CU_ASSERT_EQUAL_FATAL(samples[i], t.samples[i]);\n }\n\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n}\n\nstatic void\ntest_virtual_root_properties(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int depth;\n double time, length;\n tsk_id_t node;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_depth(&t, t.virtual_root, &depth), 0)\n CU_ASSERT_EQUAL_FATAL(depth, -1);\n\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_time(&t, t.virtual_root, &time), 0)\n /* Workaround problems in IEEE floating point macros. We may want to\n * add tsk_isinf (like tsk_isnan) at some point, but not worth it just\n * for this test case */\n CU_ASSERT_TRUE(isinf((float) time));\n\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_mrca(&t, t.virtual_root, 0, &node), 0)\n CU_ASSERT_EQUAL(node, t.virtual_root);\n\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_mrca(&t, 0, t.virtual_root, &node), 0)\n CU_ASSERT_EQUAL(node, t.virtual_root);\n\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_parent(&t, t.virtual_root, &node), 0)\n CU_ASSERT_EQUAL(node, TSK_NULL);\n\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_branch_length(&t, t.virtual_root, &length), 0)\n CU_ASSERT_EQUAL(length, 0);\n\n /* The definition of \"descendant\" is that node v is on the path from\n * u to a root. Since there is no parent link from roots to the\n * virtual_root, it's consistent with this definition to return false\n * for every node. */\n CU_ASSERT_FALSE(tsk_tree_is_descendant(&t, 0, t.virtual_root));\n CU_ASSERT_FALSE(\n tsk_tree_is_descendant(&t, t.left_child[t.virtual_root], t.virtual_root));\n CU_ASSERT_FALSE(tsk_tree_is_descendant(&t, t.virtual_root, 0));\n /* The virtual_root *is* a descendent of itself, though. This is\n * consistent with other nodes that are not \"in\" the tree being\n * descendents of themselves, despite not being roots in the tree. */\n CU_ASSERT_TRUE(tsk_tree_is_descendant(&t, t.virtual_root, t.virtual_root));\n\n CU_ASSERT_FALSE(tsk_tree_is_sample(&t, t.virtual_root));\n\n CU_ASSERT_EQUAL(tsk_tree_get_num_roots(&t), 1);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_no_sample_count_semantics(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t t;\n tsk_id_t nodes;\n tsk_size_t n;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n\n ret = tsk_tree_init(&t, &ts, TSK_NO_SAMPLE_COUNTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n CU_ASSERT_EQUAL(tsk_tree_get_num_roots(&t), 0);\n CU_ASSERT_EQUAL(tsk_tree_get_left_root(&t), TSK_NULL);\n CU_ASSERT_EQUAL(tsk_tree_preorder(&t, &nodes, &n), TSK_ERR_UNSUPPORTED_OPERATION);\n CU_ASSERT_EQUAL(tsk_tree_postorder(&t, &nodes, &n), TSK_ERR_UNSUPPORTED_OPERATION);\n CU_ASSERT_EQUAL(tsk_tree_preorder_samples_from(&t, -1, &nodes, &n),\n TSK_ERR_UNSUPPORTED_OPERATION);\n\n CU_ASSERT_EQUAL(tsk_tree_preorder_from(&t, t.virtual_root, &nodes, &n),\n TSK_ERR_UNSUPPORTED_OPERATION);\n CU_ASSERT_EQUAL(tsk_tree_postorder_from(&t, t.virtual_root, &nodes, &n),\n TSK_ERR_UNSUPPORTED_OPERATION);\n CU_ASSERT_EQUAL(tsk_tree_preorder_samples_from(&t, t.virtual_root, &nodes, &n),\n TSK_ERR_UNSUPPORTED_OPERATION);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\n/*=======================================================\n * Tree traversals\n *=======================================================*/\n\nstatic void\nverify_node_lists(tsk_size_t n, tsk_id_t *l1, tsk_id_t *l2)\n{\n tsk_size_t j;\n\n for (j = 0; j < n; j++) {\n /* printf(\"%d %d\\n\", l1[j], l2[j]); */\n CU_ASSERT_EQUAL(l1[j], l2[j]);\n }\n}\n\nstatic void\ntest_single_tree_traversal(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t t;\n tsk_size_t num_nodes = 7;\n tsk_id_t preorder[] = { 6, 4, 0, 1, 5, 2, 3 };\n tsk_id_t preorder_vr[] = { 7, 6, 4, 0, 1, 5, 2, 3 };\n tsk_id_t preorder_samples[] = { 0, 1, 2, 3 };\n tsk_id_t postorder[] = { 0, 1, 4, 2, 3, 5, 6 };\n tsk_id_t postorder_vr[] = { 0, 1, 4, 2, 3, 5, 6, 7 };\n tsk_id_t nodes[num_nodes + 1];\n tsk_size_t n;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n ret = tsk_tree_preorder(&t, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, num_nodes);\n verify_node_lists(n, nodes, preorder);\n\n ret = tsk_tree_preorder_from(&t, -1, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, num_nodes);\n verify_node_lists(n, nodes, preorder);\n\n ret = tsk_tree_preorder_from(&t, t.virtual_root, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, num_nodes + 1);\n verify_node_lists(n, nodes, preorder_vr);\n\n ret = tsk_tree_preorder_samples_from(&t, -1, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 4);\n verify_node_lists(n, nodes, preorder_samples);\n\n ret = tsk_tree_preorder_samples_from(&t, t.virtual_root, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 4);\n verify_node_lists(n, nodes, preorder_samples);\n\n ret = tsk_tree_preorder_from(&t, 5, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 3);\n verify_node_lists(n, nodes, preorder + 4);\n\n ret = tsk_tree_preorder_samples_from(&t, 5, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 2);\n verify_node_lists(n, nodes, preorder_samples + 2);\n\n ret = tsk_tree_postorder(&t, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, num_nodes);\n verify_node_lists(n, nodes, postorder);\n\n ret = tsk_tree_postorder_from(&t, -1, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, num_nodes);\n verify_node_lists(n, nodes, postorder);\n\n ret = tsk_tree_postorder_from(&t, t.virtual_root, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, num_nodes + 1);\n verify_node_lists(n, nodes, postorder_vr);\n\n ret = tsk_tree_postorder_from(&t, 4, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 3);\n verify_node_lists(n, nodes, postorder);\n\n /* Check errors */\n ret = tsk_tree_preorder_from(&t, -2, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_tree_preorder_from(&t, 8, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n ret = tsk_tree_preorder_samples_from(&t, -2, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_tree_preorder_samples_from(&t, 8, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n ret = tsk_tree_postorder_from(&t, -2, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_tree_postorder_from(&t, 8, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\n/* printed out in tree order.\n0.90┊ ┊ 11 ┊ ┊\n ┊ ┊ ┏┻┓ ┊ ┊\n0.80┊ 10 ┊ ┃ ┃ ┊ ┊\n ┊ ┏┻┓ ┊ ┃ ┃ ┊ ┊\n0.40┊ 9 ┃ ┃ ┊ 9 ┃ ┃ ┊ 9 ┊\n ┊ ┏━┻┓ ┃ ┃ ┊ ┏━┻━┓ ┃ ┃ ┊ ┏━┻━━┓ ┊\n0.30┊ ┃ ┃ ┃ ┃ ┊ ┃ 8 ┃ ┃ ┊ ┃ 8 ┊\n ┊ ┃ ┃ ┃ ┃ ┊ ┃ ┏┻┓ ┃ ┃ ┊ ┃ ┏┻┓ ┊\n0.20┊ ┃ 7 ┃ ┃ ┊ 7 ┃ ┃ ┃ ┃ ┊ 7 ┃ ┃ ┊\n ┊ ┃ ┏┻┓ ┃ ┃ ┊ ┏┻┓ ┃ ┃ ┃ ┃ ┊ ┏━┻┓ ┃ ┃ ┊\n0.10┊ ┃ ┃ ┃ ┃ ┃ ┊ ┃ ┃ ┃ ┃ ┃ ┃ ┊ ┃ 6 ┃ ┃ ┊\n ┊ ┃ ┃ ┃ ┃ ┃ ┊ ┃ ┃ ┃ ┃ ┃ ┃ ┊ ┃ ┏┻┓ ┃ ┃ ┊\n0.00┊ 5 2 3 4 0 1 ┊ 3 4 1 2 0 5 ┊ 4 0 3 1 2 5 ┊\n 0 4 8 10\n*/\n\nstatic void\ntest_multiroot_tree_traversal(void)\n{\n int ret;\n tsk_treeseq_t ts;\n\n tsk_tree_t t;\n tsk_id_t preorder[] = { 5, 9, 2, 7, 3, 4, 10, 0, 1 };\n tsk_id_t preorder_vr[] = { 12, 5, 9, 2, 7, 3, 4, 10, 0, 1 };\n tsk_id_t preorder_samples[] = { 5, 2, 3, 4, 0, 1 };\n tsk_id_t postorder[] = { 5, 2, 3, 4, 7, 9, 0, 1, 10 };\n tsk_id_t postorder_vr[] = { 5, 2, 3, 4, 7, 9, 0, 1, 10, 12 };\n tsk_id_t nodes[13];\n tsk_size_t n;\n\n tsk_treeseq_from_text(&ts, 10, multiroot_ex_nodes, multiroot_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n ret = tsk_tree_preorder(&t, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 9);\n verify_node_lists(n, nodes, preorder);\n\n ret = tsk_tree_preorder_from(&t, -1, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 9);\n verify_node_lists(n, nodes, preorder);\n\n ret = tsk_tree_preorder_from(&t, t.virtual_root, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 10);\n verify_node_lists(n, nodes, preorder_vr);\n\n ret = tsk_tree_preorder_from(&t, 10, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 3);\n verify_node_lists(n, nodes, preorder + 6);\n\n ret = tsk_tree_preorder_samples_from(&t, -1, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 6);\n verify_node_lists(n, nodes, preorder_samples);\n\n ret = tsk_tree_preorder_samples_from(&t, t.virtual_root, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 6);\n verify_node_lists(n, nodes, preorder_samples);\n\n ret = tsk_tree_preorder_samples_from(&t, 5, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 1);\n verify_node_lists(n, nodes, preorder_samples);\n\n ret = tsk_tree_preorder_samples_from(&t, 10, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 2);\n verify_node_lists(n, nodes, preorder_samples + 4);\n\n ret = tsk_tree_postorder(&t, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 9);\n verify_node_lists(n, nodes, postorder);\n\n ret = tsk_tree_postorder_from(&t, -1, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 9);\n verify_node_lists(n, nodes, postorder);\n\n ret = tsk_tree_postorder_from(&t, t.virtual_root, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 10);\n verify_node_lists(n, nodes, postorder_vr);\n\n ret = tsk_tree_postorder_from(&t, 10, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 3);\n verify_node_lists(n, nodes, postorder + 6);\n\n /* Nodes that aren't \"in\" the tree have singleton traversal lists and\n * connect to no samples */\n\n ret = tsk_tree_preorder_from(&t, 11, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 1);\n CU_ASSERT_EQUAL_FATAL(nodes[0], 11);\n\n ret = tsk_tree_postorder_from(&t, 11, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 1);\n CU_ASSERT_EQUAL_FATAL(nodes[0], 11);\n\n ret = tsk_tree_preorder_samples_from(&t, 11, nodes, &n);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(n, 0);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\nverify_seek_multi_tree(tsk_flags_t seek_options)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t t;\n double breakpoints[] = { 0, 2, 7, 10 };\n tsk_id_t num_trees = 3;\n tsk_id_t j, k;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, NULL, NULL,\n paper_ex_individuals, NULL, 0);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = 0; j < num_trees; j++) {\n ret = tsk_tree_seek(&t, breakpoints[j], seek_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t.index, j);\n ret = tsk_tree_seek_index(&t, j, seek_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t.index, j);\n for (k = 0; k < num_trees; k++) {\n ret = tsk_tree_seek(&t, breakpoints[k], seek_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t.index, k);\n ret = tsk_tree_seek_index(&t, k, seek_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t.index, k);\n }\n }\n\n ret = tsk_tree_seek(&t, 1.99999, seek_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t.index, 0);\n ret = tsk_tree_seek(&t, 6.99999, seek_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t.index, 1);\n ret = tsk_tree_seek(&t, 9.99999, seek_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t.index, 2);\n\n tsk_tree_free(&t);\n\n /* Seek to all positions from a new tree. */\n for (j = 0; j < num_trees; j++) {\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_seek(&t, breakpoints[j], seek_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t.index, j);\n tsk_tree_free(&t);\n }\n\n /* Seek to all positions from a non-new tree in the null state*/\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n for (j = 0; j < num_trees; j++) {\n ret = tsk_tree_seek(&t, 0, seek_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_prev(&t);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t.index, -1);\n ret = tsk_tree_seek(&t, breakpoints[j], seek_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(t.index, j);\n }\n tsk_tree_free(&t);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_seek_multi_tree(void)\n{\n verify_seek_multi_tree(0);\n verify_seek_multi_tree(TSK_SEEK_SKIP);\n}\n\nstatic void\ntest_seek_errors(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t t;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, NULL, NULL,\n paper_ex_individuals, NULL, 0);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_seek(&t, -1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SEEK_OUT_OF_BOUNDS);\n ret = tsk_tree_seek(&t, 10, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SEEK_OUT_OF_BOUNDS);\n ret = tsk_tree_seek(&t, 11, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SEEK_OUT_OF_BOUNDS);\n ret = tsk_tree_seek_index(&t, (tsk_id_t) ts.num_trees, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SEEK_OUT_OF_BOUNDS);\n ret = tsk_tree_seek_index(&t, -1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SEEK_OUT_OF_BOUNDS);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n}\n\n/*=======================================================\n * KC Distance tests.\n *=======================================================*/\n\nstatic void\ntest_isolated_node_kc(void)\n{\n const char *single_leaf = \"1 0 0\";\n const char *single_internal = \"0 0 0\";\n const char *edges = \"\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int ret;\n double result = 0;\n\n tsk_treeseq_from_text(&ts, 1, single_leaf, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_treeseq_kc_distance(&ts, &ts, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result, 0);\n ret = tsk_tree_init(&t, &ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n ret = tsk_tree_kc_distance(&t, &t, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result, 0);\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n\n tsk_treeseq_from_text(\n &ts, 1, single_internal, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_treeseq_kc_distance(&ts, &ts, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MULTIPLE_ROOTS);\n ret = tsk_tree_init(&t, &ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_left_root(&t), TSK_NULL);\n ret = tsk_tree_kc_distance(&t, &t, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MULTIPLE_ROOTS);\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n}\n\nstatic void\ntest_single_tree_kc(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t t, other_t;\n double result = 0;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_treeseq_kc_distance(&ts, &ts, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result, 0);\n ret = tsk_treeseq_kc_distance(&ts, &ts, 1, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result, 0);\n\n ret = tsk_tree_init(&t, &ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n ret = tsk_tree_init(&other_t, &ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&other_t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n ret = tsk_tree_copy(&t, &other_t, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n check_trees_identical(&t, &other_t);\n\n ret = tsk_tree_kc_distance(&t, &other_t, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result, 0);\n ret = tsk_tree_kc_distance(&t, &other_t, 1, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result, 0);\n\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n tsk_tree_free(&other_t);\n}\n\nstatic void\ntest_two_trees_kc(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 2 0\\n\"\n \"0 3 0\\n\";\n const char *nodes_other = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 4 0\\n\"\n \"0 6 0\\n\";\n const char *edges = \"0 1 3 0,1\\n\"\n \"0 1 4 2,3\\n\";\n int ret;\n tsk_treeseq_t ts, other_ts;\n tsk_tree_t t, other_t;\n double result = 0;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&t, &ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n tsk_treeseq_from_text(\n &other_ts, 1, nodes_other, edges, NULL, NULL, NULL, NULL, NULL, 0);\n\n ret = tsk_treeseq_kc_distance(&ts, &other_ts, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result, 0);\n ret = tsk_treeseq_kc_distance(&ts, &other_ts, 1, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(result, 4.243, 1e-2);\n\n ret = tsk_tree_init(&other_t, &other_ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&other_t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n ret = tsk_tree_kc_distance(&t, &other_t, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result, 0);\n ret = tsk_tree_kc_distance(&t, &other_t, 1, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(result, 4.243, 1e-2);\n\n tsk_treeseq_free(&ts);\n tsk_treeseq_free(&other_ts);\n tsk_tree_free(&t);\n tsk_tree_free(&other_t);\n}\n\nstatic void\ntest_empty_tree_kc(void)\n{\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_tree_t t;\n tsk_id_t v;\n int ret;\n double result = 0;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SEQUENCE_LENGTH);\n tsk_treeseq_free(&ts);\n tables.sequence_length = NAN;\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SEQUENCE_LENGTH);\n tsk_treeseq_free(&ts);\n tables.sequence_length = INFINITY;\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SEQUENCE_LENGTH);\n tsk_treeseq_free(&ts);\n tables.sequence_length = 1.0;\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n verify_empty_tree_sequence(&ts, 1.0);\n\n ret = tsk_treeseq_kc_distance(&ts, &ts, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MULTIPLE_ROOTS);\n\n ret = tsk_tree_init(&t, &ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_left_root(&t), TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(t.interval.left, 0);\n CU_ASSERT_EQUAL_FATAL(t.interval.right, 1);\n CU_ASSERT_EQUAL_FATAL(t.parent[0], TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(t.left_child[0], TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(t.right_child[0], TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(t.left_sib[0], TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(t.right_sib[0], TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_parent(&t, 1, &v), TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n ret = tsk_tree_kc_distance(&t, &t, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MULTIPLE_ROOTS);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_nonbinary_tree_kc(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\";\n const char *edges = \"0 1 4 0,1,2,3\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int ret;\n double result = 0;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n\n tsk_treeseq_kc_distance(&ts, &ts, 0, &result);\n CU_ASSERT_EQUAL_FATAL(result, 0);\n\n ret = tsk_tree_init(&t, &ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n tsk_tree_kc_distance(&t, &t, 0, &result);\n CU_ASSERT_EQUAL_FATAL(result, 0);\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n}\n\nstatic void\ntest_nonzero_samples_kc(void)\n{\n const char *nodes = \"0 0 0\\n\" /* unused node at the start */\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\";\n const char *edges = \"0 1 3 1,2\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int ret;\n double result = 0;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n\n ret = tsk_treeseq_kc_distance(&ts, &ts, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result, 0);\n\n ret = tsk_tree_init(&t, &ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n ret = tsk_tree_kc_distance(&t, &t, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result, 0);\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n}\n\nstatic void\ntest_internal_samples_kc(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 1 0\";\n const char *edges = \"0 1 2 0,1\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int ret;\n double result = 0;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n\n /* Permitted in tree sequences */\n ret = tsk_treeseq_kc_distance(&ts, &ts, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result, 0.0);\n\n ret = tsk_tree_init(&t, &ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n ret = tsk_tree_kc_distance(&t, &t, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n}\n\nstatic void\ntest_non_sample_leaf_kc(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"0 0 0\\n\"\n \"0 1 0\\n\";\n const char *edges = \"0 1 2 0,1\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int ret;\n double result = 0;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n\n ret = tsk_treeseq_kc_distance(&ts, &ts, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result, 0.0);\n\n ret = tsk_tree_init(&t, &ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n ret = tsk_tree_kc_distance(&t, &t, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result, 0.0);\n\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n}\n\nstatic void\ntest_unequal_sample_size_kc(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 2 0\\n\"\n \"0 3 0\\n\";\n const char *nodes_other = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\";\n const char *edges = \"0 1 3 0,1\\n\"\n \"0 1 4 2,3\\n\";\n const char *edges_other = \"0 1 2 0,1\\n\";\n int ret;\n tsk_treeseq_t ts, other_ts;\n tsk_tree_t t, other_t;\n double result = 0;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n tsk_treeseq_from_text(\n &other_ts, 1, nodes_other, edges_other, NULL, NULL, NULL, NULL, NULL, 0);\n\n ret = tsk_treeseq_kc_distance(&ts, &other_ts, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SAMPLE_SIZE_MISMATCH);\n\n ret = tsk_tree_init(&t, &ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n ret = tsk_tree_init(&other_t, &other_ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&other_t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n ret = tsk_tree_kc_distance(&t, &other_t, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SAMPLE_SIZE_MISMATCH);\n tsk_treeseq_free(&ts);\n tsk_treeseq_free(&other_ts);\n tsk_tree_free(&t);\n tsk_tree_free(&other_t);\n}\n\nstatic void\ntest_unequal_samples_kc(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 2 0\\n\"\n \"0 3 0\\n\";\n const char *nodes_other = \"0 0 0\\n\" /* Unused node at the start */\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 2 0\\n\"\n \"0 3 0\\n\";\n const char *edges = \"0 1 3 0,1\\n\"\n \"0 1 4 2,3\\n\";\n const char *edges_other = \"0 1 4 1,2\\n\"\n \"0 1 5 3,4\\n\";\n int ret;\n tsk_treeseq_t ts, other_ts;\n tsk_tree_t t, other_t;\n double result = 0;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n tsk_treeseq_from_text(\n &other_ts, 1, nodes_other, edges_other, NULL, NULL, NULL, NULL, NULL, 0);\n\n ret = tsk_treeseq_kc_distance(&ts, &other_ts, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SAMPLES_NOT_EQUAL);\n\n ret = tsk_tree_init(&t, &ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n ret = tsk_tree_init(&other_t, &other_ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&other_t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n ret = tsk_tree_kc_distance(&t, &other_t, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SAMPLES_NOT_EQUAL);\n\n tsk_treeseq_free(&ts);\n tsk_treeseq_free(&other_ts);\n tsk_tree_free(&t);\n tsk_tree_free(&other_t);\n}\n\nstatic void\ntest_unary_nodes_kc(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 2 0\";\n const char *edges = \"0 1 2 0,1\\n\"\n \"0 1 3 2\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int ret;\n double result = 0;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&t, &ts, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n ret = tsk_tree_kc_distance(&t, &t, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNARY_NODES);\n\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n}\n\nstatic void\ntest_no_sample_lists_kc(void)\n{\n tsk_treeseq_t ts;\n tsk_tree_t t;\n int ret = 0;\n double result = 0;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n ret = tsk_tree_kc_distance(&t, &t, 9, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NO_SAMPLE_LISTS);\n\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n}\n\nstatic void\ntest_unequal_sequence_lengths_kc(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 2 0\\n\"\n \"0 3 0\\n\";\n const char *edges_1 = \"0 1 3 0,1\\n\"\n \"0 1 4 2,3\\n\";\n const char *edges_2 = \"0 2 3 0,1\\n\"\n \"0 2 4 2,3\\n\";\n\n tsk_treeseq_t ts, other;\n int ret;\n double result = 0;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges_1, NULL, NULL, NULL, NULL, NULL, 0);\n tsk_treeseq_from_text(&other, 2, nodes, edges_2, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_treeseq_kc_distance(&ts, &other, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SEQUENCE_LENGTH_MISMATCH);\n\n tsk_treeseq_free(&ts);\n tsk_treeseq_free(&other);\n}\n\nstatic void\ntest_different_number_trees_kc(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 2 0\\n\"\n \"0 3 0\\n\"\n \"0 4 0\\n\"\n \"0 5 0\\n\";\n const char *edges = \"0 10 5 0,1\\n\"\n \"0 10 6 3,4\\n\"\n \"5 10 7 2,5\\n\"\n \"0 5 8 2\\n\"\n \"0 10 8 6\\n\"\n \"5 10 8 7\\n\"\n \"0 5 9 5,8\\n\";\n\n const char *other_nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\\n\"\n \"0 2 0\\n\"\n \"0 3 0\\n\"\n \"0 4 0\\n\";\n const char *other_edges = \"0 10 5 0,1\\n\"\n \"0 10 6 2,3\\n\"\n \"0 10 7 4,5\\n\"\n \"0 10 8 6,7\\n\";\n tsk_treeseq_t ts, other;\n double result, expected;\n int ret = 0;\n\n tsk_treeseq_from_text(&ts, 10, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n tsk_treeseq_from_text(\n &other, 10, other_nodes, other_edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_treeseq_kc_distance(&ts, &other, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n expected = (sqrt(8.0) * 5.0 + sqrt(6.0) * 5.0) / 10.0;\n CU_ASSERT_DOUBLE_EQUAL_FATAL(result, expected, 1e-2);\n\n tsk_treeseq_free(&ts);\n tsk_treeseq_free(&other);\n}\n\nstatic void\ntest_offset_trees_with_errors_kc(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 2 0\\n\"\n \"0 3 0\\n\"\n \"0 4 0\\n\";\n const char *edges = \"0 10 4 0,1\\n\"\n \"0 10 5 2,3\\n\"\n \"0 10 6 4,5\\n\";\n tsk_treeseq_t ts, other;\n double result;\n int ret = 0;\n\n tsk_treeseq_from_text(\n &ts, 10, unary_ex_nodes, unary_ex_edges, NULL, NULL, NULL, NULL, NULL, 0);\n tsk_treeseq_from_text(&other, 10, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 10);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&other), 10);\n\n ret = tsk_treeseq_kc_distance(&ts, &other, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNARY_NODES);\n\n ret = tsk_treeseq_kc_distance(&other, &ts, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNARY_NODES);\n\n tsk_treeseq_free(&ts);\n tsk_treeseq_free(&other);\n}\n\n/*=======================================================\n * Miscellaneous tests.\n *======================================================*/\n\nstatic void\ntest_genealogical_nearest_neighbours_errors(void)\n{\n int ret;\n tsk_treeseq_t ts;\n const tsk_id_t *reference_sets[2];\n tsk_id_t reference_set_0[4], reference_set_1[4];\n tsk_id_t focal[] = { 0, 1, 2, 3 };\n tsk_size_t reference_set_size[2];\n tsk_size_t num_focal = 4;\n double *A = tsk_malloc(2 * num_focal * sizeof(double));\n CU_ASSERT_FATAL(A != NULL);\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 4);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n\n ret = tsk_treeseq_genealogical_nearest_neighbours(\n &ts, focal, num_focal, reference_sets, reference_set_size, 0, 0, A);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_treeseq_genealogical_nearest_neighbours(\n &ts, focal, num_focal, reference_sets, reference_set_size, INT16_MAX, 0, A);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n\n /* Overlapping sample sets */\n reference_sets[0] = focal;\n reference_set_size[0] = 1;\n reference_sets[1] = focal;\n reference_set_size[1] = num_focal;\n ret = tsk_treeseq_genealogical_nearest_neighbours(\n &ts, focal, num_focal, reference_sets, reference_set_size, 2, 0, A);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n\n /* bad values in the sample sets */\n reference_set_0[0] = 0;\n reference_set_0[1] = 1;\n reference_set_1[0] = 2;\n reference_set_1[1] = 3;\n reference_set_size[0] = 2;\n reference_set_size[1] = 2;\n reference_sets[0] = reference_set_0;\n reference_sets[1] = reference_set_1;\n ret = tsk_treeseq_genealogical_nearest_neighbours(\n &ts, focal, num_focal, reference_sets, reference_set_size, 2, 0, A);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n reference_set_0[0] = -1;\n ret = tsk_treeseq_genealogical_nearest_neighbours(\n &ts, focal, num_focal, reference_sets, reference_set_size, 2, 0, A);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n reference_set_0[0] = (tsk_id_t) tsk_treeseq_get_num_nodes(&ts);\n ret = tsk_treeseq_genealogical_nearest_neighbours(\n &ts, focal, num_focal, reference_sets, reference_set_size, 2, 0, A);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n reference_set_0[0] = (tsk_id_t) tsk_treeseq_get_num_nodes(&ts) + 1;\n ret = tsk_treeseq_genealogical_nearest_neighbours(\n &ts, focal, num_focal, reference_sets, reference_set_size, 2, 0, A);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n /* Duplicate values in the focal sets */\n reference_set_0[0] = 1;\n ret = tsk_treeseq_genealogical_nearest_neighbours(\n &ts, focal, num_focal, reference_sets, reference_set_size, 2, 0, A);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n reference_set_0[0] = 3;\n ret = tsk_treeseq_genealogical_nearest_neighbours(\n &ts, focal, num_focal, reference_sets, reference_set_size, 2, 0, A);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n\n /* Bad sample ID */\n reference_sets[0] = focal;\n reference_set_size[0] = 1;\n reference_sets[1] = focal + 1;\n reference_set_size[1] = num_focal - 1;\n focal[0] = -1;\n ret = tsk_treeseq_genealogical_nearest_neighbours(\n &ts, focal, num_focal, reference_sets, reference_set_size, 2, 0, A);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n focal[0] = (tsk_id_t) tsk_treeseq_get_num_nodes(&ts);\n ret = tsk_treeseq_genealogical_nearest_neighbours(\n &ts, focal, num_focal, reference_sets, reference_set_size, 2, 0, A);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n focal[0] = (tsk_id_t) tsk_treeseq_get_num_nodes(&ts) + 100;\n ret = tsk_treeseq_genealogical_nearest_neighbours(\n &ts, focal, num_focal, reference_sets, reference_set_size, 2, 0, A);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n\n tsk_treeseq_free(&ts);\n free(A);\n}\n\nstatic void\ntest_single_tree_balance(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t t;\n tsk_size_t sackin, colless;\n double b1, b2;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n /* Balanced binary tree with 4 leaves */\n CU_ASSERT_EQUAL_FATAL(tsk_tree_sackin_index(&t, &sackin), 0);\n CU_ASSERT_EQUAL(sackin, 8);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_colless_index(&t, &colless), 0);\n CU_ASSERT_EQUAL(colless, 0);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_b1_index(&t, &b1), 0);\n CU_ASSERT_DOUBLE_EQUAL(b1, 2, 1e-8);\n /* Test different bases for b2_index to high-precision */\n CU_ASSERT_EQUAL_FATAL(tsk_tree_b2_index(&t, 10, &b2), 0);\n CU_ASSERT_DOUBLE_EQUAL(b2, 0.6020599913279623, 1e-14);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_b2_index(&t, 2, &b2), 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(b2, 2, 1e-16);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_b2_index(&t, 3, &b2), 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(b2, 1.2618595071429148, 1e-14);\n\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n}\n\nstatic void\ntest_multiroot_balance(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t t;\n tsk_size_t sackin;\n double b1;\n\n tsk_treeseq_from_text(&ts, 10, multiroot_ex_nodes, multiroot_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n /* 0.80┊ 10 */\n /* ┊ ┏┻┓ */\n /* 0.40┊ 9 ┃ ┃ */\n /* ┊ ┏━┻┓ ┃ ┃ */\n /* 0.30┊ ┃ ┃ ┃ ┃ */\n /* ┊ ┃ ┃ ┃ ┃ */\n /* 0.20┊ ┃ 7 ┃ ┃ */\n /* ┊ ┃ ┏┻┓ ┃ ┃ */\n /* 0.10┊ ┃ ┃ ┃ ┃ ┃ */\n /* ┊ ┃ ┃ ┃ ┃ ┃ */\n /* 0.00┊ 5 2 3 4 0 1 */\n\n CU_ASSERT_EQUAL_FATAL(tsk_tree_sackin_index(&t, &sackin), 0);\n CU_ASSERT_EQUAL(sackin, 7);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_colless_index(&t, NULL), TSK_ERR_UNDEFINED_MULTIROOT);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_b1_index(&t, &b1), 0);\n CU_ASSERT_DOUBLE_EQUAL(b1, 1.0, 1e-8);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_b2_index(&t, 10, NULL), TSK_ERR_UNDEFINED_MULTIROOT);\n\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n}\n\nstatic void\ntest_nonbinary_balance(void)\n{\n int ret;\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"1 0 0\\n\"\n \"0 1 0\";\n const char *edges = \"0 1 4 0,1,2,3\\n\";\n tsk_treeseq_t ts;\n tsk_tree_t t;\n tsk_size_t sackin, colless;\n double b1, b2;\n\n tsk_treeseq_from_text(&ts, 1, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n /* Star tree with 4 leaves */\n CU_ASSERT_EQUAL_FATAL(tsk_tree_sackin_index(&t, &sackin), 0);\n CU_ASSERT_EQUAL(sackin, 4);\n CU_ASSERT_EQUAL_FATAL(\n tsk_tree_colless_index(&t, &colless), TSK_ERR_UNDEFINED_NONBINARY);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_b1_index(&t, &b1), 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(b1, 0, 1e-8);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_b2_index(&t, 10, &b2), 0);\n CU_ASSERT_DOUBLE_EQUAL_FATAL(b1, 0, 1e-8);\n\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n}\n\nstatic void\ntest_empty_tree_balance(void)\n{\n int ret;\n tsk_table_collection_t tables;\n tsk_treeseq_t ts;\n tsk_tree_t t;\n tsk_size_t sackin, colless;\n double b1, b2;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1.0;\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n CU_ASSERT_EQUAL_FATAL(tsk_tree_sackin_index(&t, &sackin), 0);\n CU_ASSERT_EQUAL(sackin, 0);\n /* Technically wrong here because we have 0 roots, but not worth worrying about */\n CU_ASSERT_EQUAL_FATAL(\n tsk_tree_colless_index(&t, &colless), TSK_ERR_UNDEFINED_MULTIROOT);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_b1_index(&t, &b1), 0);\n CU_ASSERT_EQUAL(b1, 0);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_b2_index(&t, 10, &b2), TSK_ERR_UNDEFINED_MULTIROOT);\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n}\n\nstatic void\ntest_b2_bad_base(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_tree_t t;\n double result;\n double bad_base[] = { -2, -1, 1 };\n size_t j;\n\n tsk_treeseq_from_text(&ts, 1, single_tree_ex_nodes, single_tree_ex_edges, NULL, NULL,\n NULL, NULL, NULL, 0);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n for (j = 0; j < sizeof(bad_base) / sizeof(*bad_base); j++) {\n ret = tsk_tree_b2_index(&t, bad_base[j], &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_isfinite(result));\n }\n CU_ASSERT_FATAL(j > 0);\n\n /* this one is peculiar, in that base 0 seems to give a finite answer */\n ret = tsk_tree_b2_index(&t, 0, &result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(result, 0);\n\n tsk_treeseq_free(&ts);\n tsk_tree_free(&t);\n}\n\nstatic void\ntest_tree_errors(void)\n{\n int ret;\n tsk_size_t j;\n tsk_id_t num_nodes = 9;\n tsk_id_t u;\n tsk_node_t node;\n tsk_treeseq_t ts, other_ts;\n tsk_tree_t t, other_t;\n tsk_id_t bad_nodes[] = { num_nodes + 1, num_nodes + 2, -1 };\n tsk_id_t tracked_samples[] = { 0, 0, 0 };\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, NULL, NULL,\n paper_ex_individuals, NULL, 0);\n\n ret = tsk_tree_init(&t, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n\n /* Out-of-bounds queries */\n for (j = 0; j < sizeof(bad_nodes) / sizeof(tsk_id_t); j++) {\n u = bad_nodes[j];\n ret = tsk_tree_get_parent(&t, u, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_tree_get_time(&t, u, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_tree_get_branch_length(&t, u, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_tree_get_mrca(&t, u, 0, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_tree_get_mrca(&t, 0, u, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_tree_get_num_samples(&t, u, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_tree_get_num_tracked_samples(&t, u, NULL);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n /* Also check tree sequence methods */\n ret = tsk_treeseq_get_node(&ts, (tsk_id_t) u, &node);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n CU_ASSERT(!tsk_treeseq_is_sample(&ts, u));\n CU_ASSERT(!tsk_tree_is_sample(&t, u));\n }\n\n tracked_samples[0] = 0;\n tracked_samples[1] = (tsk_id_t) tsk_treeseq_get_num_samples(&ts);\n ret = tsk_tree_set_tracked_samples(&t, 2, tracked_samples);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_SAMPLES);\n tracked_samples[1] = (tsk_id_t) tsk_treeseq_get_num_nodes(&ts);\n ret = tsk_tree_set_tracked_samples(&t, 2, tracked_samples);\n CU_ASSERT_EQUAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n tracked_samples[1] = 0;\n ret = tsk_tree_set_tracked_samples(&t, 2, tracked_samples);\n CU_ASSERT_EQUAL(ret, TSK_ERR_DUPLICATE_SAMPLE);\n\n tsk_treeseq_from_text(&other_ts, 10, paper_ex_nodes, paper_ex_edges, NULL, NULL,\n NULL, paper_ex_individuals, NULL, 0);\n\n ret = tsk_tree_init(&other_t, &other_ts, 0);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_copy(&t, &other_t, TSK_NO_INIT);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_PARAM_VALUE);\n tsk_tree_free(&t);\n tsk_tree_free(&other_t);\n\n ret = tsk_tree_init(&t, &other_ts, TSK_NO_SAMPLE_COUNTS);\n CU_ASSERT_EQUAL(ret, 0);\n ret = tsk_tree_copy(&t, &other_t, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_UNSUPPORTED_OPERATION);\n tsk_tree_free(&other_t);\n ret = tsk_tree_copy(&t, &other_t, TSK_SAMPLE_LISTS);\n CU_ASSERT_EQUAL(ret, TSK_ERR_UNSUPPORTED_OPERATION);\n tsk_tree_free(&other_t);\n\n tsk_tree_free(&t);\n tsk_treeseq_free(&other_ts);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_treeseq_row_access_errors(void)\n{\n int ret;\n tsk_table_collection_t tables;\n tsk_treeseq_t ts;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_get_individual(&ts, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n ret = tsk_treeseq_get_node(&ts, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);\n ret = tsk_treeseq_get_edge(&ts, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EDGE_OUT_OF_BOUNDS);\n ret = tsk_treeseq_get_migration(&ts, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATION_OUT_OF_BOUNDS);\n ret = tsk_treeseq_get_site(&ts, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n ret = tsk_treeseq_get_mutation(&ts, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n ret = tsk_treeseq_get_population(&ts, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n ret = tsk_treeseq_get_provenance(&ts, 0, NULL);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_PROVENANCE_OUT_OF_BOUNDS);\n\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_treeseq_get_individuals_population_errors(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n tsk_treeseq_t ts;\n tsk_id_t output[2];\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 1.25, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 1.25, TSK_NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret_id = tsk_treeseq_get_individuals_population(&ts, output);\n CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_INDIVIDUAL_POPULATION_MISMATCH);\n\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_treeseq_get_individuals_population(void)\n{\n int ret;\n tsk_id_t ret_id;\n int j;\n tsk_table_collection_t tables;\n tsk_treeseq_t ts;\n tsk_id_t output[4];\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n for (j = 0; j < 2; j++) {\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, (tsk_id_t) j);\n }\n for (j = 0; j < 4; j++) {\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, (tsk_id_t) j);\n }\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 1.25, 0, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0.0, TSK_NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 3.0, 1, 3, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 2);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0.0, TSK_NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 3);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 1.25, 0, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 4);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_get_individuals_population(&ts, output);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(output[0], TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(output[1], 0);\n CU_ASSERT_EQUAL_FATAL(output[2], TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(output[3], 1);\n\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_treeseq_get_individuals_time_errors(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n tsk_treeseq_t ts;\n double output[2];\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 1.2, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0.8, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_get_individuals_time(&ts, output);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_INDIVIDUAL_TIME_MISMATCH);\n\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_treeseq_get_individuals_time(void)\n{\n int ret;\n tsk_id_t ret_id;\n int j;\n tsk_table_collection_t tables;\n tsk_treeseq_t ts;\n double output[4];\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n for (j = 0; j < 2; j++) {\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n }\n for (j = 0; j < 4; j++) {\n ret_id = tsk_individual_table_add_row(\n &tables.individuals, 0, NULL, 0, NULL, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n }\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 1.25, 0, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 3.25, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 3.0, 1, 3, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 2);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 3.25, 0, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 3);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 1.25, 0, 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 4);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_get_individuals_time(&ts, output);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL_FATAL(output[0], 3.25);\n CU_ASSERT_EQUAL_FATAL(output[1], 1.25);\n CU_ASSERT_FATAL(tsk_is_unknown_time(output[2]));\n CU_ASSERT_EQUAL_FATAL(output[3], 3.0);\n\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_tree_copy_flags(void)\n{\n int iret, ret;\n tsk_size_t j;\n tsk_treeseq_t ts;\n tsk_tree_t t, other_t;\n tsk_flags_t options[] = { 0, TSK_NO_SAMPLE_COUNTS, TSK_SAMPLE_LISTS,\n TSK_NO_SAMPLE_COUNTS | TSK_SAMPLE_LISTS };\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, NULL, NULL,\n paper_ex_individuals, NULL, 0);\n\n for (j = 0; j < sizeof(options) / sizeof(*options); j++) {\n ret = tsk_tree_init(&t, &ts, options[j]);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_init(&other_t, &ts, options[j]);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_copy(&t, &other_t, TSK_NO_INIT);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n check_trees_identical(&t, &other_t);\n tsk_tree_free(&other_t);\n\n while ((iret = tsk_tree_next(&t)) == TSK_TREE_OK) {\n ret = tsk_tree_copy(&t, &other_t, options[j]);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n check_trees_identical(&t, &other_t);\n tsk_tree_free(&other_t);\n }\n CU_ASSERT_EQUAL_FATAL(iret, 0);\n\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n ret = tsk_tree_copy(&t, &other_t, options[j]);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n while (true) {\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n check_trees_identical(&t, &other_t);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_next(&t), tsk_tree_next(&other_t));\n if (t.index == -1) {\n break;\n }\n }\n\n ret = tsk_tree_last(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n ret = tsk_tree_copy(&t, &other_t, TSK_NO_INIT | options[j]);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n while (true) {\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n check_trees_identical(&t, &other_t);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_prev(&t), tsk_tree_prev(&other_t));\n if (t.index == -1) {\n break;\n }\n }\n\n tsk_tree_free(&other_t);\n tsk_tree_free(&t);\n }\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_deduplicate_sites(void)\n{\n int ret;\n // Modified from paper_ex\n const char *tidy_sites = \"1 0\\n\"\n \"4.5 0\\n\"\n \"8.5 0\\n\";\n const char *tidy_mutations = \"0 2 1\\n\"\n \"0 1 2\\n\"\n \"0 6 3\\n\"\n \"0 3 4\\n\"\n \"1 0 1\\n\"\n \"1 2 2\\n\"\n \"1 4 3\\n\"\n \"1 5 4\\n\"\n \"2 5 1\\n\"\n \"2 7 2\\n\"\n \"2 1 3\\n\"\n \"2 0 4\\n\";\n const char *messy_sites = \"1 0\\n\"\n \"1 0\\n\"\n \"1 0\\n\"\n \"1 0\\n\"\n \"4.5 0\\n\"\n \"4.5 0\\n\"\n \"4.5 0\\n\"\n \"4.5 0\\n\"\n \"8.5 0\\n\"\n \"8.5 0\\n\"\n \"8.5 0\\n\"\n \"8.5 0\\n\";\n const char *messy_mutations = \"0 2 1\\n\"\n \"1 1 2\\n\"\n \"2 6 3\\n\"\n \"3 3 4\\n\"\n \"4 0 1\\n\"\n \"5 2 2\\n\"\n \"6 4 3\\n\"\n \"7 5 4\\n\"\n \"8 5 1\\n\"\n \"9 7 2\\n\"\n \"10 1 3\\n\"\n \"11 0 4\\n\";\n tsk_table_collection_t tidy, messy;\n\n ret = tsk_table_collection_init(&tidy, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_init(&messy, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n messy.sequence_length = 10;\n tidy.sequence_length = 10;\n parse_individuals(paper_ex_individuals, &tidy.individuals);\n parse_nodes(paper_ex_nodes, &tidy.nodes);\n parse_sites(tidy_sites, &tidy.sites);\n parse_mutations(tidy_mutations, &tidy.mutations);\n // test cleaning doesn't mess up the tidy one\n parse_individuals(paper_ex_individuals, &messy.individuals);\n parse_nodes(paper_ex_nodes, &messy.nodes);\n parse_sites(tidy_sites, &messy.sites);\n parse_mutations(tidy_mutations, &messy.mutations);\n\n ret = tsk_table_collection_deduplicate_sites(&messy, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_site_table_equals(&tidy.sites, &messy.sites, 0));\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&tidy.mutations, &messy.mutations, 0));\n\n tsk_site_table_clear(&messy.sites);\n tsk_mutation_table_clear(&messy.mutations);\n\n // test with the actual messy one\n parse_sites(messy_sites, &messy.sites);\n parse_mutations(messy_mutations, &messy.mutations);\n\n ret = tsk_table_collection_deduplicate_sites(&messy, 0);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_TRUE(tsk_site_table_equals(&tidy.sites, &messy.sites, 0));\n CU_ASSERT_TRUE(tsk_mutation_table_equals(&tidy.mutations, &messy.mutations, 0));\n\n tsk_table_collection_free(&tidy);\n tsk_table_collection_free(&messy);\n}\n\nstatic void\ntest_deduplicate_sites_errors(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 10;\n ret_id = tsk_site_table_add_row(&tables.sites, 2, \"A\", 1, \"m\", 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 2, \"TT\", 2, \"MM\", 2);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_mutation_table_add_row(&tables.mutations, 0, 0, -1, 0, \"T\", 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /* Negative position */\n tables.sites.position[0] = -1;\n ret = tsk_table_collection_deduplicate_sites(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_SITE_POSITION);\n tables.sites.position[0] = 2;\n\n /* unsorted position */\n tables.sites.position[1] = 0.5;\n ret = tsk_table_collection_deduplicate_sites(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_UNSORTED_SITES);\n tables.sites.position[1] = 2;\n\n /* negative site ID */\n tables.mutations.site[0] = -1;\n ret = tsk_table_collection_deduplicate_sites(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n tables.mutations.site[0] = 0;\n\n /* site ID out of bounds */\n tables.mutations.site[0] = 2;\n ret = tsk_table_collection_deduplicate_sites(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_SITE_OUT_OF_BOUNDS);\n tables.mutations.site[0] = 0;\n\n /* Bad offset in metadata */\n tables.sites.metadata_offset[0] = 2;\n ret = tsk_table_collection_deduplicate_sites(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n tables.sites.metadata_offset[0] = 0;\n\n /* Bad length in metadata */\n tables.sites.metadata_offset[2] = 100;\n ret = tsk_table_collection_deduplicate_sites(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n tables.sites.metadata_offset[2] = 3;\n\n /* Bad offset in ancestral_state */\n tables.sites.ancestral_state_offset[0] = 2;\n ret = tsk_table_collection_deduplicate_sites(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n tables.sites.ancestral_state_offset[0] = 0;\n\n /* Bad length in ancestral_state */\n tables.sites.ancestral_state_offset[2] = 100;\n ret = tsk_table_collection_deduplicate_sites(&tables, 0);\n CU_ASSERT_EQUAL(ret, TSK_ERR_BAD_OFFSET);\n tables.sites.ancestral_state_offset[2] = 3;\n\n ret = tsk_table_collection_deduplicate_sites(&tables, 0);\n CU_ASSERT_EQUAL(ret, 0);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_deduplicate_sites_zero_rows(void)\n{\n\n int ret;\n tsk_table_collection_t tables;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1;\n ret = tsk_table_collection_deduplicate_sites(&tables, 0);\n CU_ASSERT_EQUAL(ret, 0);\n CU_ASSERT_EQUAL(tables.sites.num_rows, 0)\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_deduplicate_sites_multichar(void)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 10;\n ret_id = tsk_site_table_add_row(&tables.sites, 0, \"AA\", 1, \"M\", 1);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_site_table_add_row(&tables.sites, 0, \"0\", 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_site_table_add_row(&tables.sites, 1, \"BBBBB\", 5, \"NNNNN\", 5);\n CU_ASSERT_EQUAL_FATAL(ret_id, 2);\n ret_id = tsk_site_table_add_row(&tables.sites, 1, \"0\", 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 3);\n\n ret = tsk_table_collection_deduplicate_sites(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(tables.sites.num_rows, 2);\n CU_ASSERT_EQUAL_FATAL(tables.sites.position[0], 0);\n CU_ASSERT_EQUAL_FATAL(tables.sites.position[1], 1);\n CU_ASSERT_EQUAL_FATAL(tables.sites.ancestral_state[0], 'A');\n CU_ASSERT_EQUAL_FATAL(tables.sites.ancestral_state_offset[1], 1);\n CU_ASSERT_EQUAL_FATAL(tables.sites.metadata[0], 'M');\n CU_ASSERT_EQUAL_FATAL(tables.sites.metadata_offset[1], 1);\n\n CU_ASSERT_NSTRING_EQUAL(tables.sites.ancestral_state + 1, \"BBBBB\", 5);\n CU_ASSERT_EQUAL_FATAL(tables.sites.ancestral_state_offset[2], 6);\n CU_ASSERT_NSTRING_EQUAL(tables.sites.metadata + 1, \"NNNNN\", 5);\n CU_ASSERT_EQUAL_FATAL(tables.sites.metadata_offset[2], 6);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_empty_tree_sequence(void)\n{\n tsk_treeseq_t ts;\n tsk_table_collection_t tables;\n tsk_tree_t t;\n tsk_id_t v;\n int ret;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_SEQUENCE_LENGTH);\n tsk_treeseq_free(&ts);\n tables.sequence_length = 1.0;\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n verify_empty_tree_sequence(&ts, 1.0);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_left_root(&t), TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(t.interval.left, 0);\n CU_ASSERT_EQUAL_FATAL(t.interval.right, 1);\n CU_ASSERT_EQUAL_FATAL(t.num_edges, 0);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_parent(&t, 0, &v), 0);\n CU_ASSERT_EQUAL_FATAL(v, TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_parent(&t, 1, &v), TSK_ERR_NODE_OUT_OF_BOUNDS);\n tsk_tree_free(&t);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_last(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_left_root(&t), TSK_NULL);\n CU_ASSERT_EQUAL_FATAL(t.interval.left, 0);\n CU_ASSERT_EQUAL_FATAL(t.interval.right, 1);\n CU_ASSERT_EQUAL_FATAL(tsk_tree_get_parent(&t, 1, &v), TSK_ERR_NODE_OUT_OF_BOUNDS);\n tsk_tree_free(&t);\n\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_zero_edges(void)\n{\n const char *nodes = \"1 0 0\\n\"\n \"1 0 0\\n\";\n const char *edges = \"\";\n const char *sites = \"0.1 0\\n\"\n \"0.2 0\\n\";\n const char *mutations = \"0 0 1\\n\"\n \"1 1 1\\n\";\n tsk_treeseq_t ts, tss;\n tsk_tree_t t;\n tsk_id_t samples, node_map;\n const tsk_id_t z = TSK_NULL;\n tsk_id_t parents[] = {\n z,\n z,\n };\n int ret;\n\n tsk_treeseq_from_text(&ts, 2, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&ts), 2.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&ts), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&ts), 1);\n tsk_treeseq_print_state(&ts, _devnull);\n\n verify_trees(&ts, 1, parents);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_first(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(t.interval.left, 0);\n CU_ASSERT_EQUAL(t.interval.right, 2);\n CU_ASSERT_EQUAL(t.num_edges, 0);\n CU_ASSERT_EQUAL(t.parent[0], TSK_NULL);\n CU_ASSERT_EQUAL(t.parent[1], TSK_NULL);\n CU_ASSERT_EQUAL(tsk_tree_get_left_root(&t), 0);\n CU_ASSERT_EQUAL(t.left_sib[0], TSK_NULL);\n CU_ASSERT_EQUAL(t.right_sib[0], 1);\n tsk_tree_print_state(&t, _devnull);\n tsk_tree_free(&t);\n\n ret = tsk_tree_init(&t, &ts, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_tree_last(&t);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_TREE_OK);\n CU_ASSERT_EQUAL(t.interval.left, 0);\n CU_ASSERT_EQUAL(t.interval.right, 2);\n CU_ASSERT_EQUAL(t.parent[0], TSK_NULL);\n CU_ASSERT_EQUAL(t.parent[1], TSK_NULL);\n CU_ASSERT_EQUAL(tsk_tree_get_left_root(&t), 0);\n CU_ASSERT_EQUAL(t.left_sib[0], TSK_NULL);\n CU_ASSERT_EQUAL(t.right_sib[0], 1);\n tsk_tree_print_state(&t, _devnull);\n tsk_tree_free(&t);\n\n /* We give pointers ot samples and node_map here as they must be non null */\n ret = tsk_treeseq_simplify(&ts, &samples, 0, 0, &tss, &node_map);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_samples(&tss), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_sequence_length(&tss), 2.0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&tss), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_sites(&tss), 2);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_mutations(&tss), 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&tss), 1);\n tsk_treeseq_print_state(&ts, _devnull);\n\n tsk_treeseq_free(&ts);\n tsk_treeseq_free(&tss);\n}\n\nstatic void\ntest_tree_sequence_metadata(void)\n{\n int ret;\n tsk_table_collection_t tc;\n tsk_treeseq_t ts;\n\n char example_metadata[100] = \"An example of metadata with unicode 🎄🌳🌴🌲🎋\";\n char example_metadata_schema[100]\n = \"An example of metadata schema with unicode 🎄🌳🌴🌲🎋\";\n char example_time_units[100] = \"An example of time units ⏰\";\n tsk_size_t example_metadata_length = (tsk_size_t) strlen(example_metadata);\n tsk_size_t example_time_units_length = (tsk_size_t) strlen(example_metadata_schema);\n tsk_size_t example_metadata_schema_length = (tsk_size_t) strlen(example_time_units);\n\n ret = tsk_table_collection_init(&tc, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tc.sequence_length = 1.0;\n ret = tsk_table_collection_build_index(&tc, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_set_metadata(\n &tc, example_metadata, example_metadata_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_set_metadata_schema(\n &tc, example_metadata_schema, example_metadata_schema_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_set_time_units(\n &tc, example_time_units, example_time_units_length);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_init(&ts, &tc, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_EQUAL(tsk_treeseq_get_metadata_length(&ts), example_metadata_length);\n CU_ASSERT_EQUAL(\n tsk_treeseq_get_metadata_schema_length(&ts), example_metadata_schema_length);\n CU_ASSERT_EQUAL(tsk_memcmp(tsk_treeseq_get_metadata(&ts), example_metadata,\n example_metadata_length),\n 0);\n CU_ASSERT_EQUAL(tsk_memcmp(tsk_treeseq_get_metadata_schema(&ts),\n example_metadata_schema, example_metadata_schema_length),\n 0);\n\n CU_ASSERT_EQUAL(tsk_treeseq_get_time_units_length(&ts), example_time_units_length);\n CU_ASSERT_EQUAL(tsk_memcmp(tsk_treeseq_get_time_units(&ts), example_time_units,\n example_time_units_length),\n 0);\n\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tc);\n}\n\nstatic int\ndummy_stat(tsk_size_t K, const double *X, tsk_size_t M, double *Y, void *params)\n{\n tsk_size_t k;\n CU_ASSERT_FATAL(M == K);\n CU_ASSERT_FATAL(params == NULL);\n\n for (k = 0; k < K; k++) {\n Y[k] = X[k];\n }\n return 0;\n}\n\nstatic void\ntest_time_uncalibrated(void)\n{\n int ret;\n tsk_table_collection_t tables;\n tsk_treeseq_t ts;\n tsk_treeseq_t ts2;\n tsk_size_t sample_set_sizes[] = { 2, 2 };\n tsk_id_t samples[] = { 0, 1, 2, 3 };\n tsk_size_t num_samples;\n double result[100];\n double *W;\n double *sigma;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ts.time_uncalibrated, false);\n tsk_treeseq_free(&ts);\n\n ret = tsk_table_collection_set_time_units(\n &tables, TSK_TIME_UNITS_UNCALIBRATED, strlen(TSK_TIME_UNITS_UNCALIBRATED));\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ts.time_uncalibrated, true);\n tsk_treeseq_free(&ts);\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n ret = tsk_table_collection_set_time_units(\n ts.tables, TSK_TIME_UNITS_UNCALIBRATED, strlen(TSK_TIME_UNITS_UNCALIBRATED));\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_init(&ts2, ts.tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_allele_frequency_spectrum(\n &ts2, 2, sample_set_sizes, samples, 0, NULL, 0, NULL, TSK_STAT_SITE, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_allele_frequency_spectrum(\n &ts2, 2, sample_set_sizes, samples, 0, NULL, 0, NULL, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TIME_UNCALIBRATED);\n ret = tsk_treeseq_allele_frequency_spectrum(&ts2, 2, sample_set_sizes, samples, 0,\n NULL, 0, NULL, TSK_STAT_BRANCH | TSK_STAT_ALLOW_TIME_UNCALIBRATED, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n sigma = tsk_calloc(tsk_treeseq_get_num_nodes(&ts2), sizeof(double));\n num_samples = tsk_treeseq_get_num_samples(&ts2);\n W = tsk_calloc(num_samples, sizeof(double));\n\n ret = tsk_treeseq_general_stat(&ts2, 1, W, 1, dummy_stat, NULL,\n tsk_treeseq_get_num_trees(&ts2), tsk_treeseq_get_breakpoints(&ts2),\n TSK_STAT_SITE, sigma);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_general_stat(&ts2, 1, W, 1, dummy_stat, NULL,\n tsk_treeseq_get_num_trees(&ts2), tsk_treeseq_get_breakpoints(&ts2),\n TSK_STAT_BRANCH, sigma);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TIME_UNCALIBRATED);\n ret = tsk_treeseq_general_stat(&ts2, 1, W, 1, dummy_stat, NULL,\n tsk_treeseq_get_num_trees(&ts2), tsk_treeseq_get_breakpoints(&ts2),\n TSK_STAT_BRANCH | TSK_STAT_ALLOW_TIME_UNCALIBRATED, sigma);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_divergence_matrix(\n &ts2, 0, NULL, NULL, 0, NULL, TSK_STAT_BRANCH, result);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TIME_UNCALIBRATED);\n ret = tsk_treeseq_divergence_matrix(&ts2, 0, NULL, NULL, 0, NULL,\n TSK_STAT_BRANCH | TSK_STAT_ALLOW_TIME_UNCALIBRATED, result);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_safe_free(W);\n tsk_safe_free(sigma);\n tsk_treeseq_free(&ts);\n tsk_treeseq_free(&ts2);\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_reference_sequence(void)\n{\n int ret;\n tsk_table_collection_t tables;\n tsk_treeseq_t ts;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_FALSE(tsk_treeseq_has_reference_sequence(&ts));\n tsk_treeseq_free(&ts);\n\n ret = tsk_reference_sequence_set_data(&tables.reference_sequence, \"abc\", 3);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_treeseq_has_reference_sequence(&ts));\n tsk_treeseq_free(&ts);\n\n tsk_table_collection_free(&tables);\n}\n\nstatic void\ntest_split_edges_no_populations(void)\n{\n int ret;\n tsk_treeseq_t ts, split_ts;\n tsk_table_collection_t tables;\n tsk_id_t new_nodes[] = { 9, 10, 11 };\n tsk_size_t num_new_nodes = 3;\n const char *metadata = \"some metadata\";\n tsk_size_t j;\n tsk_node_t node;\n double time = 0.09;\n tsk_id_t ret_id;\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n\n ret_id = tsk_table_collection_copy(ts.tables, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n tsk_treeseq_free(&ts);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret = tsk_table_collection_compute_mutation_times(&tables, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_treeseq_init(&ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /* NOTE: haven't worked out the exact IDs on the branches here, just\n * for illustration.\n\n 0.25┊ 8 ┊ ┊ ┊\n ┊ ┏━┻━┓ ┊ ┊ ┊\n 0.20┊ ┃ ┃ ┊ ┊ 7 ┊\n ┊ ┃ ┃ ┊ ┊ ┏━┻━┓ ┊\n 0.17┊ 6 ┃ ┊ 6 ┊ ┃ ┃ ┊\n ┊ ┏━┻┓ ┃ ┊ ┏━┻━┓ ┊ ┃ ┃ ┊\n 0.09┊ 9 5 10┊ 9 5 ┊ 11 5 ┊\n ┊ ┃ ┏┻┓ ┃ ┊ ┃ ┏━┻┓ ┊ ┃ ┏━┻┓ ┊\n 0.07┊ ┃ ┃ ┃ ┃ ┊ ┃ ┃ 4 ┊ ┃ ┃ 4 ┊\n ┊ ┃ ┃ ┃ ┃ ┊ ┃ ┃ ┏┻┓ ┊ ┃ ┃ ┏┻┓ ┊\n 0.00┊ 0 1 3 2 ┊ 0 1 2 3 ┊ 0 1 2 3 ┊\n 0.00 2.00 7.00 10.00\n */\n ret = tsk_treeseq_split_edges(\n &ts, time, 1234, 0, metadata, strlen(metadata), 0, &split_ts);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&split_ts), 3);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&split_ts), 12);\n\n for (j = 0; j < num_new_nodes; j++) {\n ret = tsk_treeseq_get_node(&split_ts, new_nodes[j], &node);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(node.time, time);\n CU_ASSERT_EQUAL(node.flags, 1234);\n CU_ASSERT_EQUAL(node.individual, TSK_NULL);\n CU_ASSERT_EQUAL(node.population, 0);\n CU_ASSERT_EQUAL(node.metadata_length, strlen(metadata));\n CU_ASSERT_EQUAL(strncmp(node.metadata, metadata, strlen(metadata)), 0);\n }\n tsk_treeseq_free(&split_ts);\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_split_edges_populations(void)\n{\n int ret;\n tsk_treeseq_t ts, split_ts;\n tsk_table_collection_t tables;\n double time = 0.5;\n tsk_node_t node;\n tsk_id_t valid_pops[] = { -1, 0, 1 };\n tsk_id_t num_valid_pops = 3;\n tsk_id_t j, population, ret_id;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, 0, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 1, 1, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0, 1, 1, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n for (j = 0; j < num_valid_pops; j++) {\n population = valid_pops[j];\n ret = tsk_treeseq_split_edges(&ts, time, 0, population, NULL, 0, 0, &split_ts);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_trees(&split_ts), 1);\n CU_ASSERT_EQUAL(tsk_treeseq_get_num_nodes(&split_ts), 3);\n ret = tsk_treeseq_get_node(&split_ts, 2, &node);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(node.population, population);\n tsk_treeseq_free(&split_ts);\n }\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_split_edges_errors(void)\n{\n int ret;\n tsk_treeseq_t ts, split_ts;\n tsk_table_collection_t tables;\n double time = 0.5;\n tsk_id_t invalid_pops[] = { -2, 2, 3 };\n tsk_id_t num_invalid_pops = 3;\n tsk_id_t j, population, ret_id;\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = 1;\n\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, 0, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret_id = tsk_node_table_add_row(&tables.nodes, 0, 1, 1, TSK_NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 1);\n ret_id = tsk_edge_table_add_row(&tables.edges, 0, 1, 1, 0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_split_edges(\n &ts, TSK_UNKNOWN_TIME, 0, TSK_NULL, NULL, 0, 0, &split_ts);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_TIME_NONFINITE);\n\n for (j = 0; j < num_invalid_pops; j++) {\n population = invalid_pops[j];\n ret = tsk_treeseq_split_edges(&ts, time, 0, population, NULL, 0, 0, &split_ts);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n tsk_treeseq_free(&split_ts);\n }\n tsk_treeseq_free(&ts);\n\n ret_id\n = tsk_migration_table_add_row(&tables.migrations, 0, 1, 0, 0, 1, 1.0, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_split_edges(&ts, time, 0, population, NULL, 0, 0, &split_ts);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATIONS_NOT_SUPPORTED);\n tsk_treeseq_free(&split_ts);\n\n tsk_table_collection_free(&tables);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_extend_haplotypes_simple(void)\n{\n int ret;\n tsk_treeseq_t ts, ets;\n const char *nodes = \"1 0 -1 -1\\n\"\n \"1 0 -1 -1\\n\"\n \"0 2.0 -1 -1\\n\";\n const char *edges = \"0 10 2 0\\n\"\n \"0 10 2 1\\n\";\n const char *sites = \"0.0 0\\n\"\n \"1.0 0\\n\";\n const char *mutations = \"0 0 1 -1 0.5\\n\"\n \"1 1 1 -1 0.5\\n\";\n\n tsk_treeseq_from_text(&ts, 10, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n ret = tsk_treeseq_extend_haplotypes(&ts, 10, 0, &ets);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE_FATAL(tsk_table_collection_equals(ts.tables, ets.tables, 0));\n tsk_treeseq_free(&ts);\n\n tsk_treeseq_free(&ets);\n}\n\nstatic void\ntest_extend_haplotypes_errors(void)\n{\n int ret;\n tsk_treeseq_t ts, ets;\n const char *nodes = \"1 0 -1 -1\\n\"\n \"1 0 -1 -1\\n\"\n \"0 2.0 -1 -1\\n\";\n const char *edges = \"0 10 2 0\\n\"\n \"0 10 2 1\\n\";\n const char *sites = \"0.0 0\\n\"\n \"1.0 0\\n\";\n const char *mutations = \"0 0 1 -1 0.5\\n\"\n \"1 1 1 -1 0.5\\n\";\n const char *mutations_no_time = \"0 0 1 -1\\n\"\n \"1 1 1 -1\\n\";\n // left, right, node source, dest, time\n const char *migrations = \"0 10 0 0 1 0.5\\n\"\n \"0 10 0 1 0 1.5\\n\";\n\n tsk_treeseq_from_text(&ts, 10, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n ret = tsk_treeseq_extend_haplotypes(&ts, -2, 0, &ets);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_EXTEND_EDGES_BAD_MAXITER);\n tsk_treeseq_free(&ts);\n\n tsk_treeseq_from_text(\n &ts, 10, nodes, edges, migrations, sites, mutations, NULL, NULL, 0);\n ret = tsk_treeseq_extend_haplotypes(&ts, 10, 0, &ets);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MIGRATIONS_NOT_SUPPORTED);\n tsk_treeseq_free(&ts);\n\n tsk_treeseq_from_text(\n &ts, 10, nodes, edges, NULL, sites, mutations_no_time, NULL, NULL, 0);\n ret = tsk_treeseq_extend_haplotypes(&ts, 10, 0, &ets);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_DISALLOWED_UNKNOWN_MUTATION_TIME);\n tsk_treeseq_free(&ts);\n\n tsk_treeseq_free(&ets);\n}\n\nstatic void\nassert_equal_except_edges_and_mutation_nodes(\n const tsk_treeseq_t *ts1, const tsk_treeseq_t *ts2)\n{\n tsk_table_collection_t t1, t2;\n int ret;\n\n ret = tsk_table_collection_copy(ts1->tables, &t1, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_table_collection_copy(ts2->tables, &t2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tsk_memset(t1.mutations.node, 0, t1.mutations.num_rows * sizeof(*t1.mutations.node));\n tsk_memset(t2.mutations.node, 0, t2.mutations.num_rows * sizeof(*t2.mutations.node));\n\n tsk_edge_table_clear(&t1.edges);\n tsk_edge_table_clear(&t2.edges);\n\n CU_ASSERT_TRUE(tsk_table_collection_equals(&t1, &t2, 0));\n\n tsk_table_collection_free(&t1);\n tsk_table_collection_free(&t2);\n}\n\nstatic void\ntest_extend_haplotypes(void)\n{\n int ret = 0;\n int max_iter = 10;\n tsk_treeseq_t ts, ets;\n FILE *tmp = fopen(_tmp_file_name, \"w\");\n\n /* 7 and 8 should be extended to the whole sequence;\n * also 5 to the second tree (where x's are)\n\n 6 6 6 6\n +-+-+ +-+-+ +-+-+ +-+-+\n | | 7 x x 8 x x\n | | ++-+ | | +-++ | |\n 4 5 4 | x 4 | 5 4 5\n +++ +++ +++ | | | | +++ +++ +++\n 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3\n */\n\n const char *nodes = \"1 0 -1 -1\\n\"\n \"1 0 -1 -1\\n\"\n \"1 0 -1 -1\\n\"\n \"1 0 -1 -1\\n\"\n \"0 1.0 -1 -1\\n\"\n \"0 1.0 -1 -1\\n\"\n \"0 3.0 -1 -1\\n\"\n \"0 2.0 -1 -1\\n\"\n \"0 2.0 -1 -1\\n\";\n // l, r, p, c\n const char *edges = \"0 10 4 0\\n\"\n \"0 5 4 1\\n\"\n \"7 10 4 1\\n\"\n \"0 2 5 2\\n\"\n \"5 10 5 2\\n\"\n \"0 2 5 3\\n\"\n \"5 10 5 3\\n\"\n \"2 5 7 2\\n\"\n \"2 5 7 4\\n\"\n \"5 7 8 1\\n\"\n \"5 7 8 5\\n\"\n \"2 5 6 3\\n\"\n \"0 2 6 4\\n\"\n \"5 10 6 4\\n\"\n \"0 2 6 5\\n\"\n \"7 10 6 5\\n\"\n \"2 5 6 7\\n\"\n \"5 7 6 8\\n\";\n const char *sites = \"0.0 0\\n\"\n \"9.0 0\\n\";\n const char *mutations = \"0 4 1 -1 2.5\\n\"\n \"0 4 2 0 1.5\\n\"\n \"1 6 3 -1 3.5\\n\"\n \"1 5 1 2 2.5\\n\"\n \"1 5 2 3 1.5\\n\";\n\n tsk_treeseq_from_text(&ts, 10, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n\n for (max_iter = 1; max_iter < 10; max_iter++) {\n ret = tsk_treeseq_extend_haplotypes(&ts, max_iter, 0, &ets);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_equal_except_edges_and_mutation_nodes(&ts, &ets);\n CU_ASSERT_TRUE(ets.tables->edges.num_rows >= 12);\n tsk_treeseq_free(&ets);\n }\n\n ret = tsk_treeseq_extend_haplotypes(&ts, max_iter, 0, &ets);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL_FATAL(ets.tables->nodes.num_rows, 9);\n CU_ASSERT_EQUAL_FATAL(ets.tables->edges.num_rows, 12);\n assert_equal_except_edges_and_mutation_nodes(&ts, &ets);\n tsk_treeseq_free(&ets);\n\n tsk_set_debug_stream(tmp);\n ret = tsk_treeseq_extend_haplotypes(&ts, max_iter, TSK_DEBUG, &ets);\n tsk_set_debug_stream(stdout);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(ftell(tmp) > 0);\n tsk_treeseq_free(&ets);\n\n fclose(tmp);\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_extend_haplotypes_conflicting_times(void)\n{\n int ret;\n int max_iter = 10;\n tsk_treeseq_t ts, ets;\n /*\n 3.00┊ 3 ┊ 4 ┊\n ┊ ┃ ┊ ┃ ┊\n 2.00┊ ┃ ┊ 2 ┊\n ┊ ┃ ┊ ┃ ┊\n 1.00┊ 1 ┊ ┃ ┊\n ┊ ┃ ┊ ┃ ┊\n 0.00┊ 0 ┊ 0 ┊\n 0 2 4\n */\n\n const char *nodes = \"1 0.0 -1 -1\\n\"\n \"0 1.0 -1 -1\\n\"\n \"0 2.0 -1 -1\\n\"\n \"0 3.0 -1 -1\\n\"\n \"0 3.0 -1 -1\\n\";\n // l, r, p, c\n const char *edges = \"0.0 2.0 1 0\\n\"\n \"2.0 4.0 2 0\\n\"\n \"0.0 2.0 3 1\\n\"\n \"2.0 4.0 4 2\\n\";\n\n tsk_treeseq_from_text(&ts, 4, nodes, edges, NULL, NULL, NULL, NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ts.tables->edges.num_rows, 4);\n\n ret = tsk_treeseq_extend_haplotypes(&ts, max_iter, 0, &ets);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ts.tables, ets.tables, 0));\n tsk_treeseq_free(&ets);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_extend_haplotypes_new_edge(void)\n{\n int ret;\n int max_iter = 10;\n tsk_treeseq_t ts, ets, ref_ts;\n /* This is an example where new edges are added\n * on both forwards and back passes\n 4.00┊ ┊ 4 ┊ 4 ┊ 4 ┊\n ┊ ┊ ┃ ┊ ┃ ┊ ┃ ┊\n 3.00┊ 2 ┊ ┃ ┊ 2 ┊ 2 ┊\n ┊ ┃ ┊ ┃ ┊ ┃ ┊ ┃ ┊\n 2.00┊ ┃ ┊ 3 ┊ ┃ ┊ 3 ┊\n ┊ ┃ ┊ ┃ ┊ ┃ ┊ ┃ ┊\n 1.00┊ 1 ┊ ┃ ┊ ┃ ┊ ┃ ┊\n ┊ ┃ ┊ ┃ ┊ ┃ ┊ ┃ ┊\n 0.00┊ 0 ┊ 0 ┊ 0 ┊ 0 ┊\n 0 2 4 6 8\n */\n\n const char *nodes = \"1 0.0 -1 -1\\n\"\n \"0 1.0 -1 -1\\n\"\n \"0 3.0 -1 -1\\n\"\n \"0 2.0 -1 -1\\n\"\n \"0 4.0 -1 -1\\n\";\n // l, r, p, c\n const char *edges = \"0.0 2.0 1 0\\n\"\n \"2.0 4.0 3 0\\n\"\n \"6.0 8.0 3 0\\n\"\n \"4.0 5.0 2 0\\n\"\n \"5.0 6.0 2 0\\n\"\n \"0.0 2.0 2 1\\n\"\n \"6.0 7.0 2 3\\n\"\n \"7.0 8.0 2 3\\n\"\n \"4.0 8.0 4 2\\n\"\n \"2.0 4.0 4 3\\n\";\n const char *ext_edges = \"0.0 8.0 1 0\\n\"\n \"0.0 8.0 3 1\\n\"\n \"0.0 8.0 2 3\\n\"\n \"2.0 8.0 4 2\\n\";\n const char *sites = \"3.0 0\\n\";\n // s, n , ds, t\n const char *mutations = \"0 4 5 -1 4.5\\n\"\n \"0 3 4 0 3.5\\n\"\n \"0 3 3 1 2.5\\n\"\n \"0 0 2 2 1.5\\n\"\n \"0 0 1 3 0.5\\n\";\n const char *ext_mutations = \"0 4 5 -1 4.5\\n\"\n \"0 2 4 0 3.5\\n\"\n \"0 3 3 1 2.5\\n\"\n \"0 1 2 2 1.5\\n\"\n \"0 0 1 3 0.5\\n\";\n\n tsk_treeseq_from_text(&ts, 8, nodes, edges, NULL, sites, mutations, NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ts.tables->edges.num_rows, 10);\n tsk_treeseq_from_text(\n &ref_ts, 8, nodes, ext_edges, NULL, sites, ext_mutations, NULL, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ref_ts.tables->edges.num_rows, 4);\n\n ret = tsk_treeseq_extend_haplotypes(&ts, max_iter, 0, &ets);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n assert_equal_except_edges_and_mutation_nodes(&ts, &ets);\n CU_ASSERT_TRUE(tsk_table_collection_equals(ets.tables, ref_ts.tables, 0));\n tsk_treeseq_free(&ets);\n\n tsk_treeseq_free(&ts);\n tsk_treeseq_free(&ref_ts);\n}\n\nstatic void\ntest_init_take_ownership_no_edge_metadata(void)\n{\n int ret;\n tsk_treeseq_t ts;\n tsk_table_collection_t *tables = tsk_malloc(sizeof(tsk_table_collection_t));\n\n CU_ASSERT_NOT_EQUAL_FATAL(tables, NULL);\n\n tsk_treeseq_from_text(&ts, 10, paper_ex_nodes, paper_ex_edges, NULL, paper_ex_sites,\n paper_ex_mutations, paper_ex_individuals, NULL, 0);\n ret = tsk_treeseq_copy_tables(&ts, tables, TSK_TC_NO_EDGE_METADATA);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n\n ret = tsk_treeseq_init(&ts, tables, TSK_TAKE_OWNERSHIP);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_CANT_TAKE_OWNERSHIP_NO_EDGE_METADATA);\n\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_init_compute_mutation_parents(void)\n{\n int ret;\n tsk_table_collection_t *tables, *tables2;\n tsk_treeseq_t ts;\n const char *sites = \"0 0\\n\";\n /* Make a mutation on a parallel branch the parent*/\n const char *bad_mutations = \"0 0 1 -1\\n\"\n \"0 1 1 0\\n\";\n\n tables = tsk_malloc(sizeof(tsk_table_collection_t));\n CU_ASSERT_NOT_EQUAL_FATAL(tables, NULL);\n tables2 = tsk_malloc(sizeof(tsk_table_collection_t));\n CU_ASSERT_NOT_EQUAL_FATAL(tables2, NULL);\n\n CU_ASSERT_FATAL(tables != NULL);\n ret = tsk_table_collection_init(tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables->sequence_length = 1;\n parse_nodes(single_tree_ex_nodes, &tables->nodes);\n CU_ASSERT_EQUAL_FATAL(tables->nodes.num_rows, 7);\n parse_edges(single_tree_ex_edges, &tables->edges);\n CU_ASSERT_EQUAL_FATAL(tables->edges.num_rows, 6);\n parse_sites(sites, &tables->sites);\n CU_ASSERT_EQUAL_FATAL(tables->sites.num_rows, 1);\n parse_mutations(bad_mutations, &tables->mutations);\n CU_ASSERT_EQUAL_FATAL(tables->mutations.num_rows, 2);\n tables->sequence_length = 1.0;\n ret = tsk_table_collection_copy(tables, tables2, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n ret = tsk_treeseq_init(&ts, tables, TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_MUTATION_PARENT);\n tsk_treeseq_free(&ts);\n\n ret = tsk_treeseq_init(\n &ts, tables, TSK_TS_INIT_BUILD_INDEXES | TSK_TS_INIT_COMPUTE_MUTATION_PARENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_treeseq_free(&ts);\n\n /* When we use take ownership, the check of parents shouldn't overwrite them*/\n ret = tsk_treeseq_init(&ts, tables, TSK_TAKE_OWNERSHIP | TSK_TS_INIT_BUILD_INDEXES);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_BAD_MUTATION_PARENT);\n CU_ASSERT_EQUAL(tables->mutations.parent[0], -1);\n CU_ASSERT_EQUAL(tables->mutations.parent[1], 0);\n tsk_treeseq_free(&ts);\n\n /* When we use take ownership and compute, the tables are overwritten*/\n ret = tsk_treeseq_init(&ts, tables2,\n TSK_TAKE_OWNERSHIP | TSK_TS_INIT_BUILD_INDEXES\n | TSK_TS_INIT_COMPUTE_MUTATION_PARENTS);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n CU_ASSERT_EQUAL(tables2->mutations.parent[0], -1);\n CU_ASSERT_EQUAL(tables2->mutations.parent[1], -1);\n\n /* Don't need to free tables as we took ownership */\n tsk_treeseq_free(&ts);\n}\n\nstatic void\ntest_init_compute_mutation_parents_errors(void)\n{\n int ret;\n tsk_id_t row_ret;\n tsk_table_collection_t tables;\n tsk_treeseq_t ts;\n const char *sites = \"0.5 0\\n\"\n \"0 0\\n\";\n\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n tables.sequence_length = 1;\n parse_nodes(single_tree_ex_nodes, &tables.nodes);\n CU_ASSERT_EQUAL_FATAL(tables.nodes.num_rows, 7);\n parse_edges(single_tree_ex_edges, &tables.edges);\n CU_ASSERT_EQUAL_FATAL(tables.edges.num_rows, 6);\n parse_sites(sites, &tables.sites);\n CU_ASSERT_EQUAL_FATAL(tables.sites.num_rows, 2);\n tables.sequence_length = 1.0;\n\n ret = tsk_treeseq_init(\n &ts, &tables, TSK_TS_INIT_BUILD_INDEXES | TSK_TS_INIT_COMPUTE_MUTATION_PARENTS);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_UNSORTED_SITES);\n tsk_treeseq_free(&ts);\n\n tsk_site_table_clear(&tables.sites);\n row_ret = tsk_site_table_add_row(&tables.sites, 0.5, \"A\", 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(row_ret, 0);\n row_ret = tsk_mutation_table_add_row(\n &tables.mutations, 0, 0, TSK_NULL, TSK_UNKNOWN_TIME, \"A\", 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(row_ret, 0);\n row_ret = tsk_mutation_table_add_row(\n &tables.mutations, 0, 4, TSK_NULL, TSK_UNKNOWN_TIME, \"A\", 1, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(row_ret, 1);\n\n ret = tsk_treeseq_init(\n &ts, &tables, TSK_TS_INIT_BUILD_INDEXES | TSK_TS_INIT_COMPUTE_MUTATION_PARENTS);\n CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_MUTATION_PARENT_AFTER_CHILD);\n tsk_treeseq_free(&ts);\n\n tsk_table_collection_free(&tables);\n}\n\nint\nmain(int argc, char **argv)\n{\n CU_TestInfo tests[] = {\n /* simplest example tests */\n { \"test_simplest_discrete_genome\", test_simplest_discrete_genome },\n { \"test_simplest_discrete_time\", test_simplest_discrete_time },\n { \"test_simplest_min_time\", test_simplest_min_time },\n { \"test_simplest_max_time\", test_simplest_max_time },\n { \"test_simplest_records\", test_simplest_records },\n { \"test_simplest_nonbinary_records\", test_simplest_nonbinary_records },\n { \"test_simplest_unary_records\", test_simplest_unary_records },\n { \"test_simplest_unary_with_individuals\", test_simplest_unary_with_individuals },\n { \"test_simplest_non_sample_leaf_records\",\n test_simplest_non_sample_leaf_records },\n { \"test_simplest_degenerate_multiple_root_records\",\n test_simplest_degenerate_multiple_root_records },\n { \"test_simplest_multiple_root_records\", test_simplest_multiple_root_records },\n { \"test_simplest_zero_root_tree\", test_simplest_zero_root_tree },\n { \"test_simplest_multi_root_tree\", test_simplest_multi_root_tree },\n { \"test_simplest_tree_mrca\", test_simplest_tree_mrca },\n { \"test_simplest_root_mutations\", test_simplest_root_mutations },\n { \"test_simplest_back_mutations\", test_simplest_back_mutations },\n { \"test_simplest_general_samples\", test_simplest_general_samples },\n { \"test_simplest_holey_tree_sequence\", test_simplest_holey_tree_sequence },\n { \"test_simplest_holey_tsk_treeseq_zero_roots\",\n test_simplest_holey_tsk_treeseq_zero_roots },\n { \"test_simplest_holey_tsk_treeseq_mutation_parents\",\n test_simplest_holey_tsk_treeseq_mutation_parents },\n { \"test_simplest_initial_gap_tree_sequence\",\n test_simplest_initial_gap_tree_sequence },\n { \"test_simplest_initial_gap_zero_roots\", test_simplest_initial_gap_zero_roots },\n { \"test_simplest_initial_gap_tsk_treeseq_mutation_parents\",\n test_simplest_initial_gap_tsk_treeseq_mutation_parents },\n { \"test_simplest_final_gap_tree_sequence\",\n test_simplest_final_gap_tree_sequence },\n { \"test_simplest_final_gap_tsk_treeseq_mutation_parents\",\n test_simplest_final_gap_tsk_treeseq_mutation_parents },\n { \"test_simplest_individuals\", test_simplest_individuals },\n { \"test_simplest_bad_individuals\", test_simplest_bad_individuals },\n { \"test_simplest_bad_edges\", test_simplest_bad_edges },\n { \"test_simplest_bad_indexes\", test_simplest_bad_indexes },\n { \"test_simplest_bad_migrations\", test_simplest_bad_migrations },\n { \"test_simplest_migration_simplify\", test_simplest_migration_simplify },\n { \"test_simplest_overlapping_parents\", test_simplest_overlapping_parents },\n { \"test_simplest_contradictory_children\", test_simplest_contradictory_children },\n { \"test_simplest_overlapping_edges_simplify\",\n test_simplest_overlapping_edges_simplify },\n { \"test_simplest_overlapping_unary_edges_simplify\",\n test_simplest_overlapping_unary_edges_simplify },\n { \"test_simplest_overlapping_unary_edges_internal_samples_simplify\",\n test_simplest_overlapping_unary_edges_internal_samples_simplify },\n { \"test_simplest_reduce_site_topology\", test_simplest_reduce_site_topology },\n { \"test_simplest_simplify_defragment\", test_simplest_simplify_defragment },\n { \"test_simplest_population_filter\", test_simplest_population_filter },\n { \"test_simplest_individual_filter\", test_simplest_individual_filter },\n { \"test_simplest_no_node_filter\", test_simplest_no_node_filter },\n { \"test_simplest_no_update_flags\", test_simplest_no_update_flags },\n { \"test_simplest_map_mutations\", test_simplest_map_mutations },\n { \"test_simplest_nonbinary_map_mutations\",\n test_simplest_nonbinary_map_mutations },\n { \"test_simplest_unary_map_mutations\", test_simplest_unary_map_mutations },\n { \"test_simplest_non_sample_leaf_map_mutations\",\n test_simplest_non_sample_leaf_map_mutations },\n { \"test_simplest_internal_sample_map_mutations\",\n test_simplest_internal_sample_map_mutations },\n { \"test_simplest_multiple_root_map_mutations\",\n test_simplest_multiple_root_map_mutations },\n { \"test_simplest_chained_map_mutations\", test_simplest_chained_map_mutations },\n { \"test_simplest_mutation_edges\", test_simplest_mutation_edges },\n\n /* Single tree tests */\n { \"test_single_tree_good_records\", test_single_tree_good_records },\n { \"test_single_nonbinary_tree_good_records\",\n test_single_nonbinary_tree_good_records },\n { \"test_single_tree_bad_records\", test_single_tree_bad_records },\n { \"test_single_tree_good_mutations\", test_single_tree_good_mutations },\n { \"test_single_tree_bad_mutations\", test_single_tree_bad_mutations },\n { \"test_single_tree_iter\", test_single_tree_iter },\n { \"test_single_tree_general_samples_iter\",\n test_single_tree_general_samples_iter },\n { \"test_single_nonbinary_tree_iter\", test_single_nonbinary_tree_iter },\n { \"test_single_tree_iter_times\", test_single_tree_iter_times },\n { \"test_single_tree_iter_depths\", test_single_tree_iter_depths },\n { \"test_single_tree_simplify\", test_single_tree_simplify },\n { \"test_single_tree_simplify_debug\", test_single_tree_simplify_debug },\n { \"test_single_tree_simplify_keep_input_roots\",\n test_single_tree_simplify_keep_input_roots },\n { \"test_single_tree_simplify_no_sample_nodes\",\n test_single_tree_simplify_no_sample_nodes },\n { \"test_single_tree_simplify_null_samples\",\n test_single_tree_simplify_null_samples },\n { \"test_single_tree_compute_mutation_parents\",\n test_single_tree_compute_mutation_parents },\n { \"test_single_tree_compute_mutation_times\",\n test_single_tree_compute_mutation_times },\n { \"test_single_tree_mutation_edges\", test_single_tree_mutation_edges },\n { \"test_single_tree_is_descendant\", test_single_tree_is_descendant },\n { \"test_single_tree_total_branch_length\", test_single_tree_total_branch_length },\n { \"test_single_tree_num_lineages\", test_single_tree_num_lineages },\n { \"test_single_tree_map_mutations\", test_single_tree_map_mutations },\n { \"test_single_tree_map_mutations_internal_samples\",\n test_single_tree_map_mutations_internal_samples },\n { \"test_single_tree_tracked_samples\", test_single_tree_tracked_samples },\n { \"test_single_tree_tree_pos\", test_single_tree_tree_pos },\n\n /* Multi tree tests */\n { \"test_simple_multi_tree\", test_simple_multi_tree },\n { \"test_multi_tree_direction_switching_tree_pos\",\n test_multi_tree_direction_switching_tree_pos },\n { \"test_nonbinary_multi_tree\", test_nonbinary_multi_tree },\n { \"test_unary_multi_tree\", test_unary_multi_tree },\n { \"test_internal_sample_multi_tree\", test_internal_sample_multi_tree },\n { \"test_internal_sample_simplified_multi_tree\",\n test_internal_sample_simplified_multi_tree },\n { \"test_simplify_keep_input_roots_multi_tree\",\n test_simplify_keep_input_roots_multi_tree },\n { \"test_left_to_right_multi_tree\", test_left_to_right_multi_tree },\n { \"test_gappy_multi_tree\", test_gappy_multi_tree },\n { \"test_convenience_arrays_multi_tree\", test_convenience_arrays_multi_tree },\n\n { \"test_tsk_treeseq_bad_records\", test_tsk_treeseq_bad_records },\n\n /* multiroot tests */\n { \"test_multiroot_mrca\", test_multiroot_mrca },\n\n /* Sample sets */\n { \"test_simple_sample_sets\", test_simple_sample_sets },\n { \"test_nonbinary_sample_sets\", test_nonbinary_sample_sets },\n { \"test_internal_sample_sample_sets\", test_internal_sample_sample_sets },\n { \"test_non_sample_leaf_sample_lists\", test_non_sample_leaf_sample_lists },\n\n { \"test_no_sample_count_semantics\", test_no_sample_count_semantics },\n { \"test_virtual_root_properties\", test_virtual_root_properties },\n\n /* tree traversal orders */\n { \"test_single_tree_traversal\", test_single_tree_traversal },\n { \"test_multiroot_tree_traversal\", test_multiroot_tree_traversal },\n\n /* Seek */\n { \"test_seek_multi_tree\", test_seek_multi_tree },\n { \"test_seek_errors\", test_seek_errors },\n\n /* KC distance tests */\n { \"test_single_tree_kc\", test_single_tree_kc },\n { \"test_isolated_node_kc\", test_isolated_node_kc },\n { \"test_two_trees_kc\", test_two_trees_kc },\n { \"test_empty_tree_kc\", test_empty_tree_kc },\n { \"test_nonbinary_tree_kc\", test_nonbinary_tree_kc },\n { \"test_nonzero_samples_kc\", test_nonzero_samples_kc },\n { \"test_internal_samples_kc\", test_internal_samples_kc },\n { \"test_non_sample_leaf_kc\", test_non_sample_leaf_kc },\n { \"test_unequal_sample_size_kc\", test_unequal_sample_size_kc },\n { \"test_unequal_samples_kc\", test_unequal_samples_kc },\n { \"test_unary_nodes_kc\", test_unary_nodes_kc },\n { \"test_no_sample_lists_kc\", test_no_sample_lists_kc },\n { \"test_unequal_sequence_lengths_kc\", test_unequal_sequence_lengths_kc },\n { \"test_different_number_trees_kc\", test_different_number_trees_kc },\n { \"test_offset_trees_with_errors_kc\", test_offset_trees_with_errors_kc },\n\n /* Tree balance/imbalance index tests */\n { \"test_single_tree_balance\", test_single_tree_balance },\n { \"test_multiroot_balance\", test_multiroot_balance },\n { \"test_nonbinary_balance\", test_nonbinary_balance },\n { \"test_empty_tree_balance\", test_empty_tree_balance },\n { \"test_b2_bad_base\", test_b2_bad_base },\n\n /* Misc */\n { \"test_tree_errors\", test_tree_errors },\n { \"test_treeseq_row_access_errors\", test_treeseq_row_access_errors },\n { \"test_treeseq_get_individuals_population_errors\",\n test_treeseq_get_individuals_population_errors },\n { \"test_treeseq_get_individuals_population\",\n test_treeseq_get_individuals_population },\n { \"test_treeseq_get_individuals_time_errors\",\n test_treeseq_get_individuals_time_errors },\n { \"test_treeseq_get_individuals_time\", test_treeseq_get_individuals_time },\n { \"test_tree_copy_flags\", test_tree_copy_flags },\n { \"test_genealogical_nearest_neighbours_errors\",\n test_genealogical_nearest_neighbours_errors },\n { \"test_deduplicate_sites\", test_deduplicate_sites },\n { \"test_deduplicate_sites_errors\", test_deduplicate_sites_errors },\n { \"test_deduplicate_sites_zero_rows\", test_deduplicate_sites_zero_rows },\n { \"test_deduplicate_sites_multichar\", test_deduplicate_sites_multichar },\n { \"test_empty_tree_sequence\", test_empty_tree_sequence },\n { \"test_zero_edges\", test_zero_edges },\n { \"test_tree_sequence_metadata\", test_tree_sequence_metadata },\n { \"test_time_uncalibrated\", test_time_uncalibrated },\n { \"test_reference_sequence\", test_reference_sequence },\n { \"test_split_edges_no_populations\", test_split_edges_no_populations },\n { \"test_split_edges_populations\", test_split_edges_populations },\n { \"test_split_edges_errors\", test_split_edges_errors },\n { \"test_extend_haplotypes_simple\", test_extend_haplotypes_simple },\n { \"test_extend_haplotypes_errors\", test_extend_haplotypes_errors },\n { \"test_extend_haplotypes\", test_extend_haplotypes },\n { \"test_extend_haplotypes_new_edge\", test_extend_haplotypes_new_edge },\n { \"test_extend_haplotypes_conflicting_times\",\n test_extend_haplotypes_conflicting_times },\n { \"test_init_take_ownership_no_edge_metadata\",\n test_init_take_ownership_no_edge_metadata },\n { \"test_init_compute_mutation_parents\", test_init_compute_mutation_parents },\n { \"test_init_compute_mutation_parents_errors\",\n test_init_compute_mutation_parents_errors },\n { NULL, NULL },\n };\n\n return test_main(tests, argc, argv);\n}\n"
},
{
"path": "c/tests/testlib.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2024 Tskit Developers\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \"testlib.h\"\n\nchar *_tmp_file_name;\nFILE *_devnull;\n\n/* Simple single tree example. */\nconst char *single_tree_ex_nodes = /* 6 */\n \"1 0 -1 -1\\n\" /* / \\ */\n \"1 0 -1 -1\\n\" /* / \\ */\n \"1 0 -1 -1\\n\" /* / \\ */\n \"1 0 -1 -1\\n\" /* / 5 */\n \"0 1 -1 -1\\n\" /* 4 / \\ */\n \"0 2 -1 -1\\n\" /* / \\ / \\ */\n \"0 3 -1 -1\\n\"; /* 0 1 2 3 */\nconst char *single_tree_ex_edges = \"0 1 4 0,1\\n\"\n \"0 1 5 2,3\\n\"\n \"0 1 6 4,5\\n\";\nconst char *single_tree_ex_sites = \"0.125 0\\n\"\n \"0.25 0\\n\"\n \"0.5 0\\n\";\n/* site, node, derived_state, [parent, time] */\nconst char *single_tree_ex_mutations\n = \"0 2 1 -1\\n\"\n \"1 4 1 -1\\n\"\n \"1 0 0 1\\n\" /* Back mutation over 0 */\n \"2 0 1 -1\\n\" /* recurrent mutations over samples */\n \"2 1 1 -1\\n\"\n \"2 2 1 -1\\n\"\n \"2 3 1 -1\\n\";\n\n/*** Example from the PLOS paper ***/\n/*\n0.25┊ 8 ┊ ┊ ┊\n ┊ ┏━┻━┓ ┊ ┊ ┊\n0.20┊ ┃ ┃ ┊ ┊ 7 ┊\n ┊ ┃ ┃ ┊ ┊ ┏━┻━┓ ┊\n0.17┊ 6 ┃ ┊ 6 ┊ ┃ ┃ ┊\n ┊ ┏━┻┓ ┃ ┊ ┏━┻━┓ ┊ ┃ ┃ ┊\n0.09┊ ┃ 5 ┃ ┊ ┃ 5 ┊ ┃ 5 ┊\n ┊ ┃ ┏┻┓ ┃ ┊ ┃ ┏━┻┓ ┊ ┃ ┏━┻┓ ┊\n0.07┊ ┃ ┃ ┃ ┃ ┊ ┃ ┃ 4 ┊ ┃ ┃ 4 ┊\n ┊ ┃ ┃ ┃ ┃ ┊ ┃ ┃ ┏┻┓ ┊ ┃ ┃ ┏┻┓ ┊\n0.00┊ 0 1 3 2 ┊ 0 1 2 3 ┊ 0 1 2 3 ┊\n 0.00 2.00 7.00 10.00\n*/\nconst char *paper_ex_nodes = \"1 0 -1 0\\n\"\n \"1 0 -1 0\\n\"\n \"1 0 -1 1\\n\"\n \"1 0 -1 1\\n\"\n \"0 0.071 -1 -1\\n\"\n \"0 0.090 -1 -1\\n\"\n \"0 0.170 -1 -1\\n\"\n \"0 0.202 -1 -1\\n\"\n \"0 0.253 -1 -1\\n\";\nconst char *paper_ex_edges = \"2 10 4 2\\n\"\n \"2 10 4 3\\n\"\n \"0 10 5 1\\n\"\n \"0 2 5 3\\n\"\n \"2 10 5 4\\n\"\n \"0 7 6 0,5\\n\"\n \"7 10 7 0,5\\n\"\n \"0 2 8 2,6\\n\";\n/* We make one mutation for each tree */\nconst char *paper_ex_sites = \"1 0\\n\"\n \"4.5 0\\n\"\n \"8.5 0\\n\";\nconst char *paper_ex_mutations = \"0 2 1\\n\"\n \"1 0 1\\n\"\n \"2 5 1\\n\";\n/* Two (diploid) individuals */\nconst char *paper_ex_individuals = \"0 0.2,1.5 -1,-1\\n\"\n \"0 0.0,0.0 -1,-1\\n\";\n\n/*** An example of a nonbinary tree sequence ***/\n/*\n0.41┊ 12 ┊ 12 ┊\n ┊ ┏━━┻━━┓ ┊ ┏━┻━━┓ ┊\n0.28┊ ┃ ┃ ┊ 11 ┃ ┊\n ┊ ┃ ┃ ┊ ┏━┻━┓ ┃ ┊\n0.13┊ ┃ 10 ┊ ┃ ┃ 10 ┊\n ┊ ┃ ┏━╋━┓ ┊ ┃ ┃ ┏┻┓ ┊\n0.07┊ 9 ┃ ┃ ┃ ┊ 9 ┃ ┃ ┃ ┊\n ┊ ┏━━┻━┓ ┃ ┃ ┃ ┊ ┏━━┻━┓ ┃ ┃ ┃ ┊\n0.01┊ 8 ┃ ┃ ┃ ┃ ┊ 8 ┃ ┃ ┃ ┃ ┊\n ┊ ┏━┳┻┳━┓ ┃ ┃ ┃ ┃ ┊ ┏━┳┻┳━┓ ┃ ┃ ┃ ┃ ┊\n0.00┊ 0 1 2 3 6 4 5 7 ┊ 0 1 2 3 6 5 4 7 ┊\n 0 17 100\n\n*/\nconst char *nonbinary_ex_nodes = \"1 0 0 -1\\n\"\n \"1 0 0 -1\\n\"\n \"1 0 0 -1\\n\"\n \"1 0 0 -1\\n\"\n \"1 0 0 -1\\n\"\n \"1 0 0 -1\\n\"\n \"1 0 0 -1\\n\"\n \"1 0 0 -1\\n\"\n \"0 0.01 0 -1\\n\"\n \"0 0.068 0 -1\\n\"\n \"0 0.130 0 -1\\n\"\n \"0 0.279 0 -1\\n\"\n \"0 0.405 0 -1\\n\";\nconst char *nonbinary_ex_edges = \"0\t100\t8\t0,1,2,3\\n\"\n \"0\t100\t9\t6,8\\n\"\n \"0 100 10 4\\n\"\n \"0 17 10 5\\n\"\n \"0 100 10 7\\n\"\n \"17\t100\t11\t5,9\\n\"\n \"0\t17\t12\t9\\n\"\n \"0 100 12 10\\n\"\n \"17\t100\t12\t11\";\nconst char *nonbinary_ex_sites = \"1 0\\n\"\n \"18 0\\n\";\nconst char *nonbinary_ex_mutations = \"0 2 1\\n\"\n \"1 11 1\";\n\n/*** An example of a tree sequence with unary nodes\n * and also a non-sample leaf (node 9). ***/\n/*\n0.25┊ 8 ┊ 8 ┊ ┊ ┊\n ┊ ┏━━┻━━┓ ┊ ┃ ┊ ┊ ┊\n0.20┊ ┃ 7 ┊ ┃ ┊ 7 ┊ ┊\n ┊ ┃ ┃ ┊ ┃ ┊ ┏━┻━━┓ ┊ ┊\n0.17┊ 6 ┃ ┊ 6 ┊ ┃ ┃ ┊ ┊\n ┊ ┏━┻━┓ ┃ ┊ ┏━┻━━┓ ┊ ┃ ┃ ┊ ┊\n0.09┊ ┃ 5 ┃ ┊ ┃ 5 ┊ ┃ 5 ┊ ┊\n ┊ ┃ ┏━╋━┓ ┃ ┊ ┃ ┏━━╋━━┓ ┊ ┃ ┏━━╋━━┓ ┊ ┊\n0.07┊ ┃ ┃ ┃ ┃ ┃ ┊ ┃ ┃ 4 ┃ ┊ ┃ ┃ 4 ┃ ┊ ┊\n ┊ ┃ ┃ ┃ ┃ ┃ ┊ ┃ ┃ ┏┻┓ ┃ ┊ ┃ ┃ ┏┻┓ ┃ ┊ ┊\n0.00┊ 0 1 3 9 2 ┊ 0 1 2 3 9 ┊ 0 1 2 3 9 ┊ 0 1 2 3 ┊\n 0 2 7 10 100\n*/\nconst char *unary_ex_nodes = \"1 0 0 -1\\n\"\n \"1 0 0 -1\\n\"\n \"1 0 0 -1\\n\"\n \"1 0 0 -1\\n\"\n \"0 0.071 0 -1\\n\"\n \"0 0.090 0 -1\\n\"\n \"0 0.170 0 -1\\n\"\n \"0 0.202 0 -1\\n\"\n \"0 0.253 0 -1\\n\"\n \"0 0 0 -1\\n\";\nconst char *unary_ex_edges = \"2 10 4 2,3\\n\"\n \"0 10 5 1\\n\"\n \"0 2 5 3\\n\"\n \"2 10 5 4\\n\"\n \"0 10 5 9\\n\"\n \"0 7 6 0,5\\n\"\n \"7 10 7 0\\n\"\n \"0 2 7 2\\n\"\n \"7 10 7 5\\n\"\n \"0 7 8 6\\n\"\n \"0 2 8 7\\n\";\n\n/* We make one mutation for each tree, over unary nodes if they exist */\nconst char *unary_ex_sites = \"1.0 0\\n\"\n \"4.5 0\\n\"\n \"8.5 0\\n\";\nconst char *unary_ex_mutations = \"0 2 1\\n\"\n \"1 6 1\\n\"\n \"1 9 0\\n\"\n \"2 5 1\\n\";\n\n/* An example of a simple tree sequence with multiple marginal trees. */\n\n/* Simple single tree example. */\nconst char *multiple_tree_ex_nodes = /* */\n \"1 0 -1 -1\\n\" /* 6 | */\n \"1 0 -1 -1\\n\" /* / \\ | */\n \"1 0 -1 -1\\n\" /* / \\ | 5 */\n \"0 1 -1 -1\\n\" /* 4 \\ | / \\ */\n \"0 2 -1 -1\\n\" /* / \\ \\ | / 3 */\n \"0 3 -1 -1\\n\" /* / \\ \\ | / / \\ */\n \"0 4 -1 -1\\n\"; /* 0 1 2 | 0 1 2 */\n /* |----------------|---------------| */\n /* 0 1 2 */\n\nconst char *multiple_tree_ex_edges = \"0.75 1.0 3 1,2\\n\"\n \"0.0 0.75 4 0,1\\n\"\n \"0.75 1.0 5 0,3\\n\"\n \"0.0 0.75 6 2,4\\n\";\n\n/* Odd topology -- different roots. */\n\nconst char *odd_tree1_ex_nodes = /* | | 5 */\n \"1 0 -1 -1\\n\" /* | 4 | | */\n \"1 0 -1 -1\\n\" /* 3 | | | | */\n \"0 1 -1 -1\\n\" /* | | | | | */\n \"0 2 -1 -1\\n\" /* 2 | 2 | 2 */\n \"0 3 -1 -1\\n\" /* / \\ | / \\ | / \\ */\n \"0 4 -1 -1\\n\"; /* 0 1 | 0 1 | 0 1 */\n /* |------|-------|------| */\n /* 0.0 0.2 0.7 1.0*/\n\nconst char *odd_tree1_ex_edges = \"0.0 1.0 2 0,1\\n\"\n \"0.0 0.2 3 2\\n\"\n \"0.2 0.7 4 2\\n\"\n \"0.7 1.0 4 2\\n\";\n\n/* An example where some samples descend from other samples, and multiple roots */\n\nconst char *multi_root_tree_ex_nodes = \"1 0 -1 -1\\n\" /* 4 5 */\n \"1 0 -1 -1\\n\" /* | | */\n \"1 1 -1 -1\\n\" /* 2 3 */\n \"1 1 -1 -1\\n\" /* | | */\n \"0 2 -1 -1\\n\" /* 0 1 */\n \"0 2 -1 -1\\n\";\n\nconst char *multi_root_tree_ex_edges = \"0 1 2 0\\n\"\n \"0 1 3 1\\n\"\n \"0 1 4 2\\n\"\n \"0 1 5 3\\n\";\n\n/* Examples of tree sequences where samples have different paths to the same ancestor. */\n\nconst char *multi_path_tree_ex_nodes = /* 5 | */\n \"1 0 -1 -1\\n\" /* / \\ | */\n \"1 0 -1 -1\\n\" /* / 4 | 4 */\n \"1 0 -1 -1\\n\" /* / / \\ | / \\ */\n \"0 1 -1 -1\\n\" /* / / \\ | 3 \\ */\n \"0 2 -1 -1\\n\" /* / / \\ | / \\ \\ */\n \"0 3 -1 -1\\n\"; /* 0 2 1 | 0 2 1 */\n /*----------------|------------ */\n /*0.0 0.2 1.0*/\n\nconst char *multi_path_tree_ex_edges = \"0.2 1.0 3 0\\n\"\n \"0.2 1.0 3 2\\n\"\n \"0.0 1.0 4 1\\n\"\n \"0.0 0.2 4 2\\n\"\n \"0.2 1.0 4 3\\n\"\n \"0.0 0.2 5 0\\n\"\n \"0.0 0.2 5 4\\n\";\n\nconst char *multi_path_tree_ex2_nodes = \"1 0 -1 -1\\n\"\n \"1 0 -1 -1\\n\"\n \"0 1 -1 -1\\n\"\n \"0 2 -1 -1\\n\"\n \"0 3 -1 -1\\n\";\n\nconst char *multi_path_tree_ex2_edges = \"0.6 1.0 2 1\\n\"\n \"0.0 1.0 3 0\\n\"\n \"0.0 0.6 4 1\\n\"\n \"0.6 1.0 4 2\\n\"\n \"0.0 1.0 4 3\\n\";\n\n/* An example of a tree sequence with internally sampled nodes. */\n\n/*\n1.20┊ ┊ 8 ┊ ┊\n ┊ ┊ ┏━┻━┓ ┊ ┊\n1.00┊ 7 ┊ ┃ ┃ ┊ ┊\n ┊ ┏━┻━┓ ┊ ┃ ┃ ┊ ┊\n0.70┊ ┃ ┃ ┊ ┃ ┃ ┊ 6 ┊\n ┊ ┃ ┃ ┊ ┃ ┃ ┊ ┏━┻━┓ ┊\n0.50┊ ┃ 5 ┊ 5 ┃ ┊ ┃ 5 ┊\n ┊ ┃ ┏━┻┓ ┊ ┏┻━┓ ┃ ┊ ┃ ┏━┻┓ ┊\n0.40┊ ┃ ┃ 4 ┊ 4 ┃ ┃ ┊ ┃ ┃ 4 ┊\n ┊ ┃ ┃ ┏┻┓ ┊ ┏┻┓ ┃ ┃ ┊ ┃ ┃ ┏┻┓ ┊\n0.20┊ ┃ ┃ ┃ 3 ┊ ┃ ┃ ┃ 3 ┊ ┃ ┃ ┃ 3 ┊\n ┊ ┃ ┃ ┃ ┊ ┃ ┃ ┃ ┊ ┃ ┃ ┃ ┊\n0.10┊ ┃ 1 2 ┊ ┃ 2 1 ┊ ┃ 1 2 ┊\n ┊ ┃ ┊ ┃ ┊ ┃ ┊\n0.00┊ 0 ┊ 0 ┊ 0 ┊\n 0.00 2.00 8.00 10.00\n*/\n\nconst char *internal_sample_ex_nodes = \"1 0.0 0 -1\\n\"\n \"1 0.1 0 -1\\n\"\n \"1 0.1 0 -1\\n\"\n \"1 0.2 0 -1\\n\"\n \"0 0.4 0 -1\\n\"\n \"1 0.5 0 -1\\n\"\n \"0 0.7 0 -1\\n\"\n \"0 1.0 0 -1\\n\"\n \"0 1.2 0 -1\\n\";\nconst char *internal_sample_ex_edges = \"2 8 4 0\\n\"\n \"0 10 4 2\\n\"\n \"0 2 4 3\\n\"\n \"8 10 4 3\\n\"\n \"0 10 5 1,4\\n\"\n \"8 10 6 0,5\\n\"\n \"0 2 7 0,5\\n\"\n \"2 8 8 3,5\\n\";\n/* We make one mutation for each tree, some above the internal node */\nconst char *internal_sample_ex_sites = \"1.0 0\\n\"\n \"4.5 0\\n\"\n \"8.5 0\\n\";\nconst char *internal_sample_ex_mutations = \"0 2 1\\n\"\n \"1 5 1\\n\"\n \"2 5 1\\n\";\n\n/*** An example of a tree sequence with multiple roots. ***/\n/*\n0.90┊ ┊ 11 ┊ ┊\n ┊ ┊ ┏┻┓ ┊ ┊\n0.80┊ 10 ┊ ┃ ┃ ┊ ┊\n ┊ ┏┻┓ ┊ ┃ ┃ ┊ ┊\n0.40┊ 9 ┃ ┃ ┊ 9 ┃ ┃ ┊ 9 ┊\n ┊ ┏━┻┓ ┃ ┃ ┊ ┏━┻━┓ ┃ ┃ ┊ ┏━┻━━┓ ┊\n0.30┊ ┃ ┃ ┃ ┃ ┊ ┃ 8 ┃ ┃ ┊ ┃ 8 ┊\n ┊ ┃ ┃ ┃ ┃ ┊ ┃ ┏┻┓ ┃ ┃ ┊ ┃ ┏┻┓ ┊\n0.20┊ ┃ 7 ┃ ┃ ┊ 7 ┃ ┃ ┃ ┃ ┊ 7 ┃ ┃ ┊\n ┊ ┃ ┏┻┓ ┃ ┃ ┊ ┏┻┓ ┃ ┃ ┃ ┃ ┊ ┏━┻┓ ┃ ┃ ┊\n0.10┊ ┃ ┃ ┃ ┃ ┃ ┊ ┃ ┃ ┃ ┃ ┃ ┃ ┊ ┃ 6 ┃ ┃ ┊\n ┊ ┃ ┃ ┃ ┃ ┃ ┊ ┃ ┃ ┃ ┃ ┃ ┃ ┊ ┃ ┏┻┓ ┃ ┃ ┊\n0.00┊ 5 2 3 4 0 1 ┊ 3 4 1 2 0 5 ┊ 4 0 3 1 2 5 ┊\n 0 4 8 10\n*/\nconst char *multiroot_ex_nodes = \"1 0.0 0 -1\\n\"\n \"1 0.0 0 -1\\n\"\n \"1 0.0 0 -1\\n\"\n \"1 0.0 0 -1\\n\"\n \"1 0.0 0 -1\\n\"\n \"1 0.0 0 -1\\n\"\n \"0 0.1 0 -1\\n\"\n \"0 0.2 0 -1\\n\"\n \"0 0.3 0 -1\\n\"\n \"0 0.4 0 -1\\n\"\n \"0 0.8 0 -1\\n\"\n \"0 0.9 0 -1\\n\";\nconst char *multiroot_ex_edges = \"8 10 6 0,3\\n\"\n \"0 8 7 3\\n\"\n \"0 10 7 4\\n\"\n \"8 10 7 6\\n\"\n \"4 10 8 1,2\\n\"\n \"0 4 9 2\\n\"\n \"0 10 9 7\\n\"\n \"4 10 9 8\\n\"\n \"0 4 10 0,1\\n\"\n \"4 8 11 0,5\\n\";\n\n/* We make one mutation over each root node */\nconst char *multiroot_ex_sites = \"1.0 0\\n\"\n \"2.0 0\\n\"\n \"3.0 0\\n\"\n \"5.0 0\\n\"\n \"6.0 0\\n\"\n \"8.0 0\\n\"\n \"9.0 0\\n\";\nconst char *multiroot_ex_mutations = \"0 10 1\\n\"\n \"1 9 1\\n\"\n \"2 5 1\\n\"\n \"3 11 1\\n\"\n \"4 9 1\\n\"\n \"5 9 1\\n\"\n \"6 5 1\\n\";\n\n/*** An example of a empty tree sequence. ***/\nconst char *empty_ex_nodes = \"1 0.0 0 -1\\n\"\n \"1 0.0 0 -1\\n\"\n \"1 0.0 0 -1\\n\"\n \"1 0.0 0 -1\\n\"\n \"1 0.0 0 -1\\n\"\n \"1 0.0 0 -1\\n\";\nconst char *empty_ex_edges = \"\";\n\n/*** An example of a tree sequence with missing marginal trees. ***/\n/*\n | 4 | | 4 |\n | / \\ | | / \\ |\n | 3 \\ | | / 3 |\n | / \\ \\ | | / / \\ |\n | 0 1 2 | | 0 1 2 |\n |-|-----------|-|-----------|-|\n 0 1 2 3 4 5\n*/\nconst char *missing_ex_nodes = \"1 0.0 0 -1\\n\"\n \"1 0.0 0 -1\\n\"\n \"1 0.0 0 -1\\n\"\n \"0 1.0 0 -1\\n\"\n \"0 2.0 0 -1\\n\";\n\nconst char *missing_ex_edges = \"1.0 2.0 3 0\\n\"\n \"1.0 2.0 3 1\\n\"\n \"3.0 4.0 3 1\\n\"\n \"3.0 4.0 3 2\\n\"\n \"3.0 4.0 4 0\\n\"\n \"1.0 2.0 4 2\\n\"\n \"1.0 2.0 4 3\\n\"\n \"3.0 4.0 4 3\\n\";\n\n/* Simple utilities to parse text so we can write declaritive\n * tests. This is not intended as a robust general input mechanism.\n */\n\nvoid\nparse_nodes(const char *text, tsk_node_table_t *node_table)\n{\n tsk_id_t ret_id;\n size_t c, k;\n size_t MAX_LINE = 1024;\n char line[MAX_LINE];\n const char *whitespace = \" \\t\";\n char *p;\n double time;\n int flags, population, individual;\n char *name;\n\n c = 0;\n while (text[c] != '\\0') {\n /* Fill in the line */\n k = 0;\n while (text[c] != '\\n' && text[c] != '\\0') {\n CU_ASSERT_FATAL(k < MAX_LINE - 1);\n line[k] = text[c];\n c++;\n k++;\n }\n if (text[c] == '\\n') {\n c++;\n }\n line[k] = '\\0';\n p = strtok(line, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n flags = atoi(p);\n p = strtok(NULL, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n time = atof(p);\n p = strtok(NULL, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n population = atoi(p);\n p = strtok(NULL, whitespace);\n if (p == NULL) {\n individual = -1;\n } else {\n individual = atoi(p);\n p = strtok(NULL, whitespace);\n }\n if (p == NULL) {\n name = \"\";\n } else {\n name = p;\n }\n ret_id = tsk_node_table_add_row(\n node_table, flags, time, population, individual, name, strlen(name));\n CU_ASSERT_FATAL(ret_id >= 0);\n }\n}\n\nvoid\nparse_edges(const char *text, tsk_edge_table_t *edge_table)\n{\n tsk_id_t ret_id;\n size_t c, k;\n size_t MAX_LINE = 1024;\n char line[MAX_LINE], sub_line[MAX_LINE];\n const char *whitespace = \" \\t\";\n char *p, *q;\n double left, right;\n tsk_id_t parent, child;\n uint32_t num_children;\n\n c = 0;\n while (text[c] != '\\0') {\n /* Fill in the line */\n k = 0;\n while (text[c] != '\\n' && text[c] != '\\0') {\n CU_ASSERT_FATAL(k < MAX_LINE - 1);\n line[k] = text[c];\n c++;\n k++;\n }\n if (text[c] == '\\n') {\n c++;\n }\n line[k] = '\\0';\n p = strtok(line, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n left = atof(p);\n p = strtok(NULL, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n right = atof(p);\n p = strtok(NULL, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n parent = atoi(p);\n num_children = 0;\n p = strtok(NULL, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n\n num_children = 1;\n q = p;\n while (*q != '\\0') {\n if (*q == ',') {\n num_children++;\n }\n q++;\n }\n CU_ASSERT_FATAL(num_children >= 1);\n strncpy(sub_line, p, MAX_LINE);\n q = strtok(sub_line, \",\");\n for (k = 0; k < num_children; k++) {\n CU_ASSERT_FATAL(q != NULL);\n child = atoi(q);\n ret_id = tsk_edge_table_add_row(\n edge_table, left, right, parent, child, NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n q = strtok(NULL, \",\");\n }\n CU_ASSERT_FATAL(q == NULL);\n }\n}\n\nvoid\nparse_migrations(const char *text, tsk_migration_table_t *migration_table)\n{\n tsk_id_t ret_id;\n size_t c, k;\n size_t MAX_LINE = 1024;\n char line[MAX_LINE];\n const char *whitespace = \" \\t\";\n char *p;\n double left, right, time;\n int node, source, dest;\n char *metadata;\n\n c = 0;\n while (text[c] != '\\0') {\n /* Fill in the line */\n k = 0;\n while (text[c] != '\\n' && text[c] != '\\0') {\n CU_ASSERT_FATAL(k < MAX_LINE - 1);\n line[k] = text[c];\n c++;\n k++;\n }\n if (text[c] == '\\n') {\n c++;\n }\n line[k] = '\\0';\n p = strtok(line, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n left = atof(p);\n p = strtok(NULL, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n right = atof(p);\n p = strtok(NULL, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n node = atoi(p);\n p = strtok(NULL, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n source = atoi(p);\n p = strtok(NULL, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n dest = atoi(p);\n p = strtok(NULL, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n time = atof(p);\n p = strtok(NULL, whitespace);\n if (p == NULL) {\n metadata = \"\";\n } else {\n metadata = p;\n }\n ret_id = tsk_migration_table_add_row(migration_table, left, right, node, source,\n dest, time, metadata, strlen(metadata));\n CU_ASSERT_FATAL(ret_id >= 0);\n }\n}\n\nvoid\nparse_sites(const char *text, tsk_site_table_t *site_table)\n{\n tsk_id_t ret_id;\n size_t c, k;\n size_t MAX_LINE = 1024;\n char line[MAX_LINE];\n double position;\n char ancestral_state[MAX_LINE];\n const char *whitespace = \" \\t\";\n char *p;\n\n c = 0;\n while (text[c] != '\\0') {\n /* Fill in the line */\n k = 0;\n while (text[c] != '\\n' && text[c] != '\\0') {\n CU_ASSERT_FATAL(k < MAX_LINE - 1);\n line[k] = text[c];\n c++;\n k++;\n }\n if (text[c] == '\\n') {\n c++;\n }\n line[k] = '\\0';\n p = strtok(line, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n position = atof(p);\n p = strtok(NULL, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n strncpy(ancestral_state, p, MAX_LINE);\n ret_id = tsk_site_table_add_row(\n site_table, position, ancestral_state, strlen(ancestral_state), NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n }\n}\n\nvoid\nparse_mutations(const char *text, tsk_mutation_table_t *mutation_table)\n{\n tsk_id_t ret_id;\n size_t c, k;\n size_t MAX_LINE = 1024;\n char line[MAX_LINE];\n const char *whitespace = \" \\t\";\n char *p;\n tsk_id_t node, site, parent;\n double time;\n char derived_state[MAX_LINE];\n\n /* site, node, derived_state, [parent, time] */\n c = 0;\n while (text[c] != '\\0') {\n /* Fill in the line */\n k = 0;\n while (text[c] != '\\n' && text[c] != '\\0') {\n CU_ASSERT_FATAL(k < MAX_LINE - 1);\n line[k] = text[c];\n c++;\n k++;\n }\n if (text[c] == '\\n') {\n c++;\n }\n line[k] = '\\0';\n p = strtok(line, whitespace);\n site = atoi(p);\n CU_ASSERT_FATAL(p != NULL);\n p = strtok(NULL, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n node = atoi(p);\n p = strtok(NULL, whitespace);\n CU_ASSERT_FATAL(p != NULL);\n strncpy(derived_state, p, MAX_LINE);\n parent = TSK_NULL;\n p = strtok(NULL, whitespace);\n if (p != NULL) {\n parent = atoi(p);\n }\n time = TSK_UNKNOWN_TIME;\n p = strtok(NULL, whitespace);\n if (p != NULL) {\n time = atof(p);\n }\n ret_id = tsk_mutation_table_add_row(mutation_table, site, node, parent, time,\n derived_state, strlen(derived_state), NULL, 0);\n CU_ASSERT_FATAL(ret_id >= 0);\n }\n}\n\nvoid\nparse_individuals(const char *text, tsk_individual_table_t *individual_table)\n{\n tsk_id_t ret_id;\n size_t c, k;\n size_t MAX_LINE = 1024;\n char line[MAX_LINE];\n char sub_line[MAX_LINE];\n const char *whitespace = \" \\t\";\n char *p, *q;\n char *p_cont, *q_cont; // re-entrant pointers for strtok_r\n double location[MAX_LINE];\n int location_len;\n tsk_id_t parents[MAX_LINE];\n int parents_len;\n int flags;\n char *name;\n\n c = 0;\n while (text[c] != '\\0') {\n /* Fill in the line */\n k = 0;\n while (text[c] != '\\n' && text[c] != '\\0') {\n CU_ASSERT_FATAL(k < MAX_LINE - 1);\n line[k] = text[c];\n c++;\n k++;\n }\n if (text[c] == '\\n') {\n c++;\n }\n line[k] = '\\0';\n p = strtok_r(line, whitespace, &p_cont);\n CU_ASSERT_FATAL(p != NULL);\n flags = atoi(p);\n\n p = strtok_r(NULL, whitespace, &p_cont);\n CU_ASSERT_FATAL(p != NULL);\n // the locations are comma-separated\n location_len = 1;\n q = p;\n while (*q != '\\0') {\n if (*q == ',') {\n location_len++;\n }\n q++;\n }\n CU_ASSERT_FATAL(location_len >= 1);\n strncpy(sub_line, p, MAX_LINE);\n q = strtok_r(sub_line, \",\", &q_cont);\n for (k = 0; k < location_len; k++) {\n CU_ASSERT_FATAL(q != NULL);\n location[k] = atof(q);\n q = strtok_r(NULL, \",\", &q_cont);\n }\n CU_ASSERT_FATAL(q == NULL);\n\n /* parents and name are optional */\n p = strtok_r(NULL, whitespace, &p_cont);\n parents_len = 0;\n name = \"\";\n if (p != NULL) {\n // the parents are comma-separated\n parents_len = 1;\n q = p;\n while (*q != '\\0') {\n if (*q == ',') {\n parents_len++;\n }\n q++;\n }\n CU_ASSERT_FATAL(parents_len >= 1);\n strncpy(sub_line, p, MAX_LINE);\n q = strtok_r(sub_line, \",\", &q_cont);\n for (k = 0; k < parents_len; k++) {\n CU_ASSERT_FATAL(q != NULL);\n parents[k] = atoi(q);\n q = strtok_r(NULL, \",\", &q_cont);\n }\n CU_ASSERT_FATAL(q == NULL);\n p = strtok_r(NULL, whitespace, &p_cont);\n if (p != NULL) {\n name = p;\n }\n }\n ret_id = tsk_individual_table_add_row(individual_table, flags, location,\n location_len, parents, parents_len, name, strlen(name));\n CU_ASSERT_FATAL(ret_id >= 0);\n }\n}\n\nvoid\ntsk_treeseq_from_text(tsk_treeseq_t *ts, double sequence_length, const char *nodes,\n const char *edges, const char *migrations, const char *sites, const char *mutations,\n const char *individuals, const char *provenance, tsk_flags_t tc_options)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_table_collection_t tables;\n tsk_id_t max_population_id;\n tsk_size_t j;\n tsk_flags_t ts_flags;\n bool all_parents_null;\n\n CU_ASSERT_FATAL(ts != NULL);\n CU_ASSERT_FATAL(nodes != NULL);\n CU_ASSERT_FATAL(edges != NULL);\n /* Not supporting provenance here for now */\n CU_ASSERT_FATAL(provenance == NULL);\n\n ret = tsk_table_collection_init(&tables, tc_options);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tables.sequence_length = sequence_length;\n parse_nodes(nodes, &tables.nodes);\n parse_edges(edges, &tables.edges);\n if (sites != NULL) {\n parse_sites(sites, &tables.sites);\n }\n if (mutations != NULL) {\n parse_mutations(mutations, &tables.mutations);\n }\n if (individuals != NULL) {\n parse_individuals(individuals, &tables.individuals);\n }\n if (migrations != NULL) {\n parse_migrations(migrations, &tables.migrations);\n }\n /* We need to add in populations if they are referenced */\n max_population_id = -1;\n for (j = 0; j < tables.nodes.num_rows; j++) {\n max_population_id = TSK_MAX(max_population_id, tables.nodes.population[j]);\n }\n for (j = 0; j < tables.migrations.num_rows; j++) {\n max_population_id = TSK_MAX(max_population_id, tables.migrations.source[j]);\n max_population_id = TSK_MAX(max_population_id, tables.migrations.dest[j]);\n }\n if (max_population_id >= 0) {\n for (j = 0; j <= (tsk_size_t) max_population_id; j++) {\n ret_id = tsk_population_table_add_row(&tables.populations, NULL, 0);\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n }\n }\n\n /* If all mutation.parent are TSK_NULL, use TSK_TS_COMPUTE_MUTATION_PARENTS flag too\n */\n ts_flags = TSK_TS_INIT_BUILD_INDEXES;\n all_parents_null = true;\n for (j = 0; j < tables.mutations.num_rows; j++) {\n if (tables.mutations.parent[j] != TSK_NULL) {\n all_parents_null = false;\n break;\n }\n }\n if (all_parents_null) {\n ts_flags |= TSK_TS_INIT_COMPUTE_MUTATION_PARENTS;\n }\n\n ret = tsk_treeseq_init(ts, &tables, ts_flags);\n /* tsk_treeseq_print_state(ts, stdout); */\n if (ret != 0) {\n printf(\"\\nret = %s\\n\", tsk_strerror(ret));\n }\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_table_collection_free(&tables);\n}\n\n/* Returns a tree sequence consisting of a single tree with n samples. This\n * is a full example of the data model, with values included for all fields.\n */\ntsk_treeseq_t *\ncaterpillar_tree(tsk_size_t n, tsk_size_t num_sites, tsk_size_t num_mutations)\n{\n int ret;\n tsk_id_t ret_id;\n tsk_treeseq_t *ts = tsk_malloc(sizeof(tsk_treeseq_t));\n tsk_table_collection_t tables;\n tsk_id_t j, k, last_node, u;\n int state, m;\n double position[2];\n tsk_id_t parents[2] = { -1, -1 };\n const char *states[] = { \"0\", \"1\" };\n const char *metadata[] = { \"This\", \"is\", \"some\", \"metadata\" };\n const int num_metadatas = sizeof(metadata) / sizeof(*metadata);\n const char *metadata_schema = \"mock metadata schema\";\n const char *ts_metadata = \"This is a caterpillar tree\";\n const char *ts_metadata_schema = \"The metadata is an example\";\n const char *prov_timestamp = \"a timestamp, should be ISO8601\";\n const char *prov_record = \"Produced by caterpillar_tree for testing purposes\";\n\n CU_ASSERT_FATAL(ts != NULL);\n ret = tsk_table_collection_init(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n\n CU_ASSERT_FATAL(num_sites > 0 && num_mutations < n - 1);\n\n tables.sequence_length = 1.0;\n\n tsk_table_collection_set_metadata(&tables, ts_metadata, strlen(ts_metadata));\n tsk_table_collection_set_metadata_schema(\n &tables, ts_metadata_schema, strlen(ts_metadata_schema));\n tsk_reference_sequence_set_metadata_schema(\n &tables.reference_sequence, ts_metadata_schema, strlen(ts_metadata_schema));\n tsk_reference_sequence_set_metadata(\n &tables.reference_sequence, ts_metadata, strlen(ts_metadata));\n tsk_reference_sequence_set_data(&tables.reference_sequence, \"A\", 1);\n tsk_reference_sequence_set_url(&tables.reference_sequence, \"B\", 1);\n\n tsk_population_table_set_metadata_schema(\n &tables.populations, metadata_schema, strlen(metadata_schema));\n tsk_individual_table_set_metadata_schema(\n &tables.individuals, metadata_schema, strlen(metadata_schema));\n tsk_node_table_set_metadata_schema(\n &tables.nodes, metadata_schema, strlen(metadata_schema));\n tsk_edge_table_set_metadata_schema(\n &tables.edges, metadata_schema, strlen(metadata_schema));\n tsk_site_table_set_metadata_schema(\n &tables.sites, metadata_schema, strlen(metadata_schema));\n tsk_mutation_table_set_metadata_schema(\n &tables.mutations, metadata_schema, strlen(metadata_schema));\n tsk_migration_table_set_metadata_schema(\n &tables.migrations, metadata_schema, strlen(metadata_schema));\n\n for (j = 0; j < (tsk_id_t) n; j++) {\n position[0] = j;\n position[1] = j;\n m = j % num_metadatas;\n ret_id = tsk_population_table_add_row(\n &tables.populations, metadata[m], strlen(metadata[m]));\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n ret_id = tsk_individual_table_add_row(&tables.individuals, 0, position, 2,\n parents, 2, metadata[m], strlen(metadata[m]));\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n ret_id = tsk_node_table_add_row(&tables.nodes, TSK_NODE_IS_SAMPLE, 0, j, j,\n metadata[m], strlen(metadata[m]));\n CU_ASSERT_EQUAL_FATAL(ret_id, j);\n }\n last_node = 0;\n for (j = 0; j < n - 1; j++) {\n m = j % num_metadatas;\n ret_id = tsk_node_table_add_row(\n &tables.nodes, 0, j + 1, j % n, TSK_NULL, metadata[m], strlen(metadata[m]));\n CU_ASSERT_FATAL(ret_id >= 0);\n u = ret_id;\n ret_id = tsk_edge_table_add_row(\n &tables.edges, 0, 1, u, last_node, metadata[m], strlen(metadata[m]));\n CU_ASSERT_FATAL(ret_id >= 0);\n ret_id = tsk_edge_table_add_row(\n &tables.edges, 0, 1, u, j + 1, metadata[m], strlen(metadata[m]));\n CU_ASSERT_FATAL(ret_id >= 0);\n last_node = u;\n }\n for (j = 0; j < num_sites; j++) {\n m = j % num_metadatas;\n ret_id = tsk_site_table_add_row(&tables.sites, (j + 1) / (double) n, states[0],\n strlen(states[0]), metadata[m], strlen(metadata[m]));\n CU_ASSERT_FATAL(ret_id >= 0);\n u = 2 * n - 3;\n state = 0;\n for (k = 0; k < num_mutations; k++) {\n m = k % num_metadatas;\n state = (state + 1) % 2;\n ret_id = tsk_mutation_table_add_row(&tables.mutations, j, u, TSK_NULL,\n tables.nodes.time[u], states[state], strlen(states[state]), metadata[m],\n strlen(metadata[m]));\n CU_ASSERT_FATAL(ret_id >= 0);\n u--;\n }\n }\n ret_id = tsk_provenance_table_add_row(&tables.provenances, prov_timestamp,\n strlen(prov_timestamp), prov_record, strlen(prov_record));\n CU_ASSERT_EQUAL_FATAL(ret_id, 0);\n\n /* TODO make these consistent with the caterpillar tree topology. */\n for (j = 0; j < n - 1; j++) {\n m = j % num_metadatas;\n ret_id = tsk_migration_table_add_row(&tables.migrations, 0, 1, j, j, j + 1,\n j + 1.5, metadata[m], strlen(metadata[m]));\n CU_ASSERT_FATAL(ret_id >= 0);\n }\n\n ret = tsk_table_collection_sort(&tables, 0, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_build_index(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_table_collection_compute_mutation_parents(&tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n ret = tsk_treeseq_init(ts, &tables, 0);\n CU_ASSERT_EQUAL_FATAL(ret, 0);\n tsk_table_collection_free(&tables);\n return ts;\n}\n\nvoid\nunsort_edges(tsk_edge_table_t *edges, size_t start)\n{\n size_t j, k;\n size_t n = edges->num_rows - start;\n tsk_edge_t *buff = tsk_malloc(n * sizeof(tsk_edge_t));\n CU_ASSERT_FATAL(buff != NULL);\n\n for (j = 0; j < n; j++) {\n k = start + j;\n buff[j].left = edges->left[k];\n buff[j].right = edges->right[k];\n buff[j].parent = edges->parent[k];\n buff[j].child = edges->child[k];\n }\n for (j = 0; j < n; j++) {\n k = start + j;\n edges->left[k] = buff[n - j - 1].left;\n edges->right[k] = buff[n - j - 1].right;\n edges->parent[k] = buff[n - j - 1].parent;\n edges->child[k] = buff[n - j - 1].child;\n }\n free(buff);\n}\n\nstatic int\ntskit_suite_init(void)\n{\n int fd = -1;\n static char template[] = \"/tmp/tsk_c_test_XXXXXX\";\n\n _tmp_file_name = NULL;\n _devnull = NULL;\n\n _tmp_file_name = tsk_malloc(sizeof(template));\n if (_tmp_file_name == NULL) {\n return CUE_NOMEMORY;\n }\n strcpy(_tmp_file_name, template);\n fd = mkstemp(_tmp_file_name);\n if (fd == -1) {\n return CUE_SINIT_FAILED;\n }\n close(fd);\n _devnull = fopen(\"/dev/null\", \"w\");\n if (_devnull == NULL) {\n return CUE_SINIT_FAILED;\n }\n return CUE_SUCCESS;\n}\n\nstatic int\ntskit_suite_cleanup(void)\n{\n if (_tmp_file_name != NULL) {\n unlink(_tmp_file_name);\n free(_tmp_file_name);\n }\n if (_devnull != NULL) {\n fclose(_devnull);\n }\n return CUE_SUCCESS;\n}\n\nstatic void\nhandle_cunit_error(void)\n{\n fprintf(stderr, \"CUnit error occured: %d: %s\\n\", CU_get_error(), CU_get_error_msg());\n exit(EXIT_FAILURE);\n}\n\nint\ntest_main(CU_TestInfo *tests, int argc, char **argv)\n{\n int ret;\n CU_pTest test;\n CU_pSuite suite;\n CU_SuiteInfo suites[] = {\n {\n .pName = \"tskit\",\n .pInitFunc = tskit_suite_init,\n .pCleanupFunc = tskit_suite_cleanup,\n .pTests = tests,\n },\n CU_SUITE_INFO_NULL,\n };\n if (CUE_SUCCESS != CU_initialize_registry()) {\n handle_cunit_error();\n }\n if (CUE_SUCCESS != CU_register_suites(suites)) {\n handle_cunit_error();\n }\n CU_basic_set_mode(CU_BRM_VERBOSE);\n\n if (argc == 1) {\n CU_basic_run_tests();\n } else if (argc == 2) {\n suite = CU_get_suite_by_name(\"tskit\", CU_get_registry());\n if (suite == NULL) {\n printf(\"Suite not found\\n\");\n return EXIT_FAILURE;\n }\n test = CU_get_test_by_name(argv[1], suite);\n if (test == NULL) {\n printf(\"Test '%s' not found\\n\", argv[1]);\n return EXIT_FAILURE;\n }\n CU_basic_run_test(suite, test);\n } else {\n printf(\"usage: %s \\n\", argv[0]);\n return EXIT_FAILURE;\n }\n\n ret = EXIT_SUCCESS;\n if (CU_get_number_of_tests_failed() != 0) {\n printf(\"Test failed!\\n\");\n ret = EXIT_FAILURE;\n }\n CU_cleanup_registry();\n return ret;\n}\n"
},
{
"path": "c/tests/testlib.h",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2024 Tskit Developers\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#ifndef __TESTLIB_H__\n#define __TESTLIB_H__\n\n#define _GNU_SOURCE\n#include \n#include \n#include \n\n#include \n#include \n\n/* Global variables used in the test suite */\n\nextern char *_tmp_file_name;\nextern FILE *_devnull;\n\nint test_main(CU_TestInfo *tests, int argc, char **argv);\n\nvoid tsk_treeseq_from_text(tsk_treeseq_t *ts, double sequence_length, const char *nodes,\n const char *edges, const char *migrations, const char *sites, const char *mutations,\n const char *individuals, const char *provenance, tsk_flags_t tc_options);\ntsk_treeseq_t *caterpillar_tree(\n tsk_size_t num_samples, tsk_size_t num_sites, tsk_size_t num_mutations);\n\nvoid parse_nodes(const char *text, tsk_node_table_t *node_table);\nvoid parse_edges(const char *text, tsk_edge_table_t *edge_table);\nvoid parse_sites(const char *text, tsk_site_table_t *site_table);\nvoid parse_mutations(const char *text, tsk_mutation_table_t *mutation_table);\nvoid parse_individuals(const char *text, tsk_individual_table_t *individual_table);\n\nvoid unsort_edges(tsk_edge_table_t *edges, size_t start);\n\n/* Use a macro so we can get line numbers at roughly the right place */\n#define assert_arrays_almost_equal(len, a, b) \\\n { \\\n do { \\\n tsk_size_t _j; \\\n for (_j = 0; _j < len; _j++) { \\\n CU_ASSERT_DOUBLE_EQUAL(a[_j], b[_j], 1e-9); \\\n } \\\n } while (0); \\\n }\n\n#define assert_arrays_equal(len, a, b) \\\n { \\\n do { \\\n tsk_size_t _j; \\\n for (_j = 0; _j < len; _j++) { \\\n CU_ASSERT_EQUAL(a[_j], b[_j]); \\\n } \\\n } while (0); \\\n }\n\n/* Array equality if the arrays contain NaN values\n NB: the float cast for NaNs is for mingw, which complains without */\n#define assert_arrays_almost_equal_nan(len, a, b) \\\n { \\\n do { \\\n tsk_size_t _j; \\\n for (_j = 0; _j < len; _j++) { \\\n if (isnan((float) a[_j]) || isnan((float) b[_j])) { \\\n CU_ASSERT_EQUAL_FATAL(isnan((float) a[_j]), isnan((float) b[_j])); \\\n } else { \\\n CU_ASSERT_DOUBLE_EQUAL(a[_j], b[_j], 1e-9); \\\n } \\\n } \\\n } while (0); \\\n }\n\nextern const char *single_tree_ex_nodes;\nextern const char *single_tree_ex_edges;\nextern const char *single_tree_ex_sites;\nextern const char *single_tree_ex_mutations;\n\nextern const char *multiple_tree_ex_nodes;\nextern const char *multiple_tree_ex_edges;\n\nextern const char *odd_tree1_ex_nodes;\nextern const char *odd_tree1_ex_edges;\n\nextern const char *multi_root_tree_ex_nodes;\nextern const char *multi_root_tree_ex_edges;\n\nextern const char *multi_path_tree_ex_nodes;\nextern const char *multi_path_tree_ex_edges;\n\nextern const char *nonbinary_ex_nodes;\nextern const char *nonbinary_ex_edges;\nextern const char *nonbinary_ex_sites;\nextern const char *nonbinary_ex_mutations;\n\nextern const char *unary_ex_nodes;\nextern const char *unary_ex_edges;\nextern const char *unary_ex_sites;\nextern const char *unary_ex_mutations;\n\nextern const char *internal_sample_ex_nodes;\nextern const char *internal_sample_ex_edges;\nextern const char *internal_sample_ex_sites;\nextern const char *internal_sample_ex_mutations;\n\nextern const char *multiroot_ex_nodes;\nextern const char *multiroot_ex_edges;\nextern const char *multiroot_ex_sites;\nextern const char *multiroot_ex_mutations;\n\nextern const char *empty_ex_nodes;\nextern const char *empty_ex_edges;\n\nextern const char *paper_ex_nodes;\nextern const char *paper_ex_edges;\nextern const char *paper_ex_sites;\nextern const char *paper_ex_mutations;\nextern const char *paper_ex_individuals;\n\nextern const char *missing_ex_nodes;\nextern const char *missing_ex_edges;\n\n#endif\n"
},
{
"path": "c/tskit/convert.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2018-2025 Tskit Developers\n * Copyright (c) 2015-2017 University of Oxford\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n\n/* ======================================================== *\n * Newick output.\n * ======================================================== */\n\n/* This infrastructure is left-over from an earlier more complex version\n * of this algorithm that worked over a tree sequence and cached the newick\n * subtrees, updating according to diffs. It's unclear whether this complexity\n * was of any real-world use, since newick output for large trees is pretty\n * pointless. */\n\ntypedef struct {\n unsigned int precision;\n tsk_flags_t options;\n char *newick;\n tsk_id_t *traversal_stack;\n const tsk_tree_t *tree;\n} tsk_newick_converter_t;\n\nstatic int\ntsk_newick_converter_run(\n tsk_newick_converter_t *self, tsk_id_t root, size_t buffer_size, char *buffer)\n{\n int ret = TSK_ERR_GENERIC;\n const tsk_tree_t *tree = self->tree;\n tsk_id_t *stack = self->traversal_stack;\n const double *time = self->tree->tree_sequence->tables->nodes.time;\n const tsk_flags_t *flags = self->tree->tree_sequence->tables->nodes.flags;\n int stack_top = 0;\n int label;\n size_t s = 0;\n int r;\n tsk_id_t u, v, w, root_parent;\n double branch_length;\n bool ms_labels = self->options & TSK_NEWICK_LEGACY_MS_LABELS;\n const char *label_format = ms_labels ? \"%d\" : \"n%d\";\n\n if (root < 0 || root >= (tsk_id_t) self->tree->num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n if (buffer == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n root_parent = tree->parent[root];\n stack[0] = root;\n u = root_parent;\n while (stack_top >= 0) {\n v = stack[stack_top];\n if (tree->left_child[v] != TSK_NULL && v != u) {\n if (s >= buffer_size) {\n ret = tsk_trace_error(TSK_ERR_BUFFER_OVERFLOW);\n goto out;\n }\n buffer[s] = '(';\n s++;\n for (w = tree->right_child[v]; w != TSK_NULL; w = tree->left_sib[w]) {\n stack_top++;\n stack[stack_top] = w;\n }\n } else {\n u = tree->parent[v];\n stack_top--;\n label = -1;\n if (ms_labels) {\n if (tree->left_child[v] == TSK_NULL) {\n label = (int) v + 1;\n }\n } else if (flags[v] & TSK_NODE_IS_SAMPLE) {\n label = (int) v;\n }\n if (label != -1) {\n if (s >= buffer_size) {\n ret = tsk_trace_error(TSK_ERR_BUFFER_OVERFLOW);\n goto out;\n }\n r = snprintf(buffer + s, buffer_size - s, label_format, label);\n if (r < 0) {\n ret = tsk_trace_error(TSK_ERR_IO);\n goto out;\n }\n s += (size_t) r;\n if (s >= buffer_size) {\n ret = tsk_trace_error(TSK_ERR_BUFFER_OVERFLOW);\n goto out;\n }\n }\n if (u != root_parent) {\n branch_length = (time[u] - time[v]);\n r = snprintf(buffer + s, buffer_size - s, \":%.*f\", (int) self->precision,\n branch_length);\n if (r < 0) {\n ret = tsk_trace_error(TSK_ERR_IO);\n goto out;\n }\n s += (size_t) r;\n if (s >= buffer_size) {\n ret = tsk_trace_error(TSK_ERR_BUFFER_OVERFLOW);\n goto out;\n }\n if (v == tree->right_child[u]) {\n buffer[s] = ')';\n } else {\n buffer[s] = ',';\n }\n s++;\n }\n }\n }\n if ((s + 1) >= buffer_size) {\n ret = tsk_trace_error(TSK_ERR_BUFFER_OVERFLOW);\n goto out;\n }\n buffer[s] = ';';\n buffer[s + 1] = '\\0';\n ret = 0;\nout:\n return ret;\n}\n\nstatic int\ntsk_newick_converter_init(tsk_newick_converter_t *self, const tsk_tree_t *tree,\n unsigned int precision, tsk_flags_t options)\n{\n int ret = 0;\n\n tsk_memset(self, 0, sizeof(tsk_newick_converter_t));\n self->precision = precision;\n self->options = options;\n self->tree = tree;\n self->traversal_stack\n = tsk_malloc(tsk_tree_get_size_bound(tree) * sizeof(*self->traversal_stack));\n if (self->traversal_stack == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_newick_converter_free(tsk_newick_converter_t *self)\n{\n tsk_safe_free(self->traversal_stack);\n return 0;\n}\n\nint\ntsk_convert_newick(const tsk_tree_t *tree, tsk_id_t root, unsigned int precision,\n tsk_flags_t options, size_t buffer_size, char *buffer)\n{\n int ret = 0;\n tsk_newick_converter_t nc;\n\n ret = tsk_newick_converter_init(&nc, tree, precision, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_newick_converter_run(&nc, root, buffer_size, buffer);\nout:\n tsk_newick_converter_free(&nc);\n return ret;\n}\n"
},
{
"path": "c/tskit/convert.h",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2018-2021 Tskit Developers\n * Copyright (c) 2015-2017 University of Oxford\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#ifndef TSK_CONVERT_H\n#define TSK_CONVERT_H\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#include \n\n#define TSK_NEWICK_LEGACY_MS_LABELS (1 << 0)\n\nint tsk_convert_newick(const tsk_tree_t *tree, tsk_id_t root, unsigned int precision,\n tsk_flags_t options, size_t buffer_size, char *buffer);\n\n#ifdef __cplusplus\n}\n#endif\n#endif\n"
},
{
"path": "c/tskit/core.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2025 Tskit Developers\n * Copyright (c) 2015-2018 University of Oxford\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#define UUID_NUM_BYTES 16\n\n#if defined(_WIN32)\n\n#include \n#include \n\nstatic int TSK_WARN_UNUSED\nget_random_bytes(uint8_t *buf)\n{\n /* Based on CPython's code in bootstrap_hash.c */\n int ret = 0;\n HCRYPTPROV hCryptProv = (HCRYPTPROV) NULL;\n\n if (!CryptAcquireContext(\n &hCryptProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {\n ret = tsk_trace_error(TSK_ERR_GENERATE_UUID);\n goto out;\n }\n if (!CryptGenRandom(hCryptProv, (DWORD) UUID_NUM_BYTES, buf)) {\n ret = tsk_trace_error(TSK_ERR_GENERATE_UUID);\n goto out;\n }\n if (!CryptReleaseContext(hCryptProv, 0)) {\n hCryptProv = (HCRYPTPROV) NULL;\n ret = tsk_trace_error(TSK_ERR_GENERATE_UUID);\n goto out;\n }\n hCryptProv = (HCRYPTPROV) NULL;\nout:\n if (hCryptProv != (HCRYPTPROV) NULL) {\n CryptReleaseContext(hCryptProv, 0);\n }\n return ret;\n}\n\n#else\n\n/* Assuming the existance of /dev/urandom on Unix platforms */\nstatic int TSK_WARN_UNUSED\nget_random_bytes(uint8_t *buf)\n{\n int ret = 0;\n FILE *f = fopen(\"/dev/urandom\", \"r\");\n\n if (f == NULL) {\n ret = tsk_trace_error(TSK_ERR_GENERATE_UUID);\n goto out;\n }\n if (fread(buf, UUID_NUM_BYTES, 1, f) != 1) {\n ret = tsk_trace_error(TSK_ERR_GENERATE_UUID);\n goto out;\n }\n if (fclose(f) != 0) {\n ret = tsk_trace_error(TSK_ERR_GENERATE_UUID);\n goto out;\n }\nout:\n return ret;\n}\n\n#endif\n\n/* Generate a new UUID4 using a system-generated source of randomness.\n * Note that this function writes a NULL terminator to the end of this\n * string, so that the total length of the buffer must be 37 bytes.\n */\nint\ntsk_generate_uuid(char *dest, int TSK_UNUSED(flags))\n{\n int ret = 0;\n uint8_t buf[UUID_NUM_BYTES];\n const char *pattern\n = \"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x\";\n\n ret = get_random_bytes(buf);\n if (ret != 0) {\n goto out;\n }\n if (snprintf(dest, TSK_UUID_SIZE + 1, pattern, buf[0], buf[1], buf[2], buf[3],\n buf[4], buf[5], buf[6], buf[7], buf[8], buf[9], buf[10], buf[11], buf[12],\n buf[13], buf[14], buf[15])\n < 0) {\n ret = tsk_trace_error(TSK_ERR_GENERATE_UUID);\n goto out;\n }\nout:\n return ret;\n}\n\nstatic const char *\ntsk_strerror_internal(int err)\n{\n const char *ret = \"Unknown error\";\n\n switch (err) {\n case 0:\n ret = \"Normal exit condition. This is not an error!\";\n break;\n\n /* General errors */\n case TSK_ERR_GENERIC:\n ret = \"Generic error; please file a bug report. (TSK_ERR_GENERIC)\";\n break;\n case TSK_ERR_NO_MEMORY:\n ret = \"Out of memory. (TSK_ERR_NO_MEMORY)\";\n break;\n case TSK_ERR_IO:\n if (errno != 0) {\n ret = strerror(errno);\n } else {\n ret = \"Unspecified IO error\";\n }\n break;\n case TSK_ERR_BAD_PARAM_VALUE:\n ret = \"Bad parameter value provided. (TSK_ERR_BAD_PARAM_VALUE)\";\n break;\n case TSK_ERR_BUFFER_OVERFLOW:\n ret = \"Supplied buffer is too small. (TSK_ERR_BUFFER_OVERFLOW)\";\n break;\n case TSK_ERR_UNSUPPORTED_OPERATION:\n ret = \"Operation cannot be performed in current configuration. \"\n \"(TSK_ERR_UNSUPPORTED_OPERATION)\";\n break;\n case TSK_ERR_GENERATE_UUID:\n ret = \"Error generating UUID. (TSK_ERR_GENERATE_UUID)\";\n break;\n case TSK_ERR_EOF:\n ret = \"End of file. (TSK_ERR_EOF)\";\n break;\n\n /* File format errors */\n case TSK_ERR_FILE_FORMAT:\n ret = \"File format error. (TSK_ERR_FILE_FORMAT)\";\n break;\n case TSK_ERR_FILE_VERSION_TOO_OLD:\n ret = \"tskit file version too old. Please upgrade using the \"\n \"'tskit upgrade' command from tskit version<0.6.2. \"\n \"(TSK_ERR_FILE_VERSION_TOO_OLD)\";\n break;\n case TSK_ERR_FILE_VERSION_TOO_NEW:\n ret = \"tskit file version is too new for this instance. \"\n \"Please upgrade tskit to the latest version. \"\n \"(TSK_ERR_FILE_VERSION_TOO_NEW)\";\n break;\n case TSK_ERR_REQUIRED_COL_NOT_FOUND:\n ret = \"A required column was not found in the file. \"\n \"(TSK_ERR_REQUIRED_COL_NOT_FOUND)\";\n break;\n case TSK_ERR_BOTH_COLUMNS_REQUIRED:\n ret = \"Both columns in a related pair must be provided. \"\n \"(TSK_ERR_BOTH_COLUMNS_REQUIRED)\";\n break;\n case TSK_ERR_BAD_COLUMN_TYPE:\n ret = \"An incompatible type for a column was found in the file. \"\n \"(TSK_ERR_BAD_COLUMN_TYPE)\";\n break;\n\n /* Out of bounds errors */\n case TSK_ERR_BAD_OFFSET:\n ret = \"Bad offset provided in input array. (TSK_ERR_BAD_OFFSET)\";\n break;\n case TSK_ERR_NODE_OUT_OF_BOUNDS:\n ret = \"Node out of bounds. (TSK_ERR_NODE_OUT_OF_BOUNDS)\";\n break;\n case TSK_ERR_EDGE_OUT_OF_BOUNDS:\n ret = \"Edge out of bounds. (TSK_ERR_EDGE_OUT_OF_BOUNDS)\";\n break;\n case TSK_ERR_POPULATION_OUT_OF_BOUNDS:\n ret = \"Population out of bounds. (TSK_ERR_POPULATION_OUT_OF_BOUNDS)\";\n break;\n case TSK_ERR_SITE_OUT_OF_BOUNDS:\n ret = \"Site out of bounds. (TSK_ERR_SITE_OUT_OF_BOUNDS)\";\n break;\n case TSK_ERR_MUTATION_OUT_OF_BOUNDS:\n ret = \"Mutation out of bounds. (TSK_ERR_MUTATION_OUT_OF_BOUNDS)\";\n break;\n case TSK_ERR_MIGRATION_OUT_OF_BOUNDS:\n ret = \"Migration out of bounds. (TSK_ERR_MIGRATION_OUT_OF_BOUNDS)\";\n break;\n case TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS:\n ret = \"Individual out of bounds. (TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS)\";\n break;\n case TSK_ERR_PROVENANCE_OUT_OF_BOUNDS:\n ret = \"Provenance out of bounds. (TSK_ERR_PROVENANCE_OUT_OF_BOUNDS)\";\n break;\n case TSK_ERR_TIME_NONFINITE:\n ret = \"Times must be finite. (TSK_ERR_TIME_NONFINITE)\";\n break;\n case TSK_ERR_GENOME_COORDS_NONFINITE:\n ret = \"Genome coordinates must be finite numbers. \"\n \"(TSK_ERR_GENOME_COORDS_NONFINITE)\";\n break;\n case TSK_ERR_SEEK_OUT_OF_BOUNDS:\n ret = \"Tree seek position out of bounds. (TSK_ERR_SEEK_OUT_OF_BOUNDS)\";\n break;\n case TSK_ERR_KEEP_ROWS_MAP_TO_DELETED:\n ret = \"One of the kept rows in the table refers to a deleted row. \"\n \"(TSK_ERR_KEEP_ROWS_MAP_TO_DELETED)\";\n break;\n case TSK_ERR_POSITION_OUT_OF_BOUNDS:\n ret = \"Position out of bounds. (TSK_ERR_POSITION_OUT_OF_BOUNDS)\";\n break;\n\n /* Edge errors */\n case TSK_ERR_NULL_PARENT:\n ret = \"Edge parent is null. (TSK_ERR_NULL_PARENT)\";\n break;\n case TSK_ERR_NULL_CHILD:\n ret = \"Edge child is null. (TSK_ERR_NULL_CHILD)\";\n break;\n case TSK_ERR_EDGES_NOT_SORTED_PARENT_TIME:\n ret = \"Edges must be listed in (time[parent], child, left) order;\"\n \" time[parent] order violated. (TSK_ERR_EDGES_NOT_SORTED_PARENT_TIME)\";\n break;\n case TSK_ERR_EDGES_NONCONTIGUOUS_PARENTS:\n ret = \"All edges for a given parent must be contiguous. \"\n \"(TSK_ERR_EDGES_NONCONTIGUOUS_PARENTS)\";\n break;\n case TSK_ERR_EDGES_NOT_SORTED_CHILD:\n ret = \"Edges must be listed in (time[parent], child, left) order;\"\n \" child order violated. (TSK_ERR_EDGES_NOT_SORTED_CHILD)\";\n break;\n case TSK_ERR_EDGES_NOT_SORTED_LEFT:\n ret = \"Edges must be listed in (time[parent], child, left) order;\"\n \" left order violated. (TSK_ERR_EDGES_NOT_SORTED_LEFT)\";\n break;\n case TSK_ERR_BAD_NODE_TIME_ORDERING:\n ret = \"time[parent] must be greater than time[child]. \"\n \"(TSK_ERR_BAD_NODE_TIME_ORDERING)\";\n break;\n case TSK_ERR_BAD_EDGE_INTERVAL:\n ret = \"Bad edge interval where right <= left. (TSK_ERR_BAD_EDGE_INTERVAL)\";\n break;\n case TSK_ERR_DUPLICATE_EDGES:\n ret = \"Duplicate edges provided. (TSK_ERR_DUPLICATE_EDGES)\";\n break;\n case TSK_ERR_RIGHT_GREATER_SEQ_LENGTH:\n ret = \"Right coordinate > sequence length. \"\n \"(TSK_ERR_RIGHT_GREATER_SEQ_LENGTH)\";\n break;\n case TSK_ERR_LEFT_LESS_ZERO:\n ret = \"Left coordinate must be >= 0. (TSK_ERR_LEFT_LESS_ZERO)\";\n break;\n case TSK_ERR_BAD_EDGES_CONTRADICTORY_CHILDREN:\n ret = \"Bad edges: contradictory children for a given parent over \"\n \"an interval, or indexes need to be rebuilt. \"\n \"(TSK_ERR_BAD_EDGES_CONTRADICTORY_CHILDREN)\";\n break;\n case TSK_ERR_CANT_PROCESS_EDGES_WITH_METADATA:\n ret = \"Can't squash, flush, simplify or link ancestors with edges that have \"\n \"non-empty metadata. Removing the metadata from the edges will allow \"\n \"these operations to proceed. For example using \"\n \"tables.edges.drop_metadata() in the tskit Python API. \"\n \"(TSK_ERR_CANT_PROCESS_EDGES_WITH_METADATA)\";\n break;\n\n /* Site errors */\n case TSK_ERR_UNSORTED_SITES:\n ret = \"Sites must be provided in strictly increasing position order. \"\n \"(TSK_ERR_UNSORTED_SITES)\";\n break;\n case TSK_ERR_DUPLICATE_SITE_POSITION:\n ret = \"Duplicate site positions. (TSK_ERR_DUPLICATE_SITE_POSITION)\";\n break;\n case TSK_ERR_BAD_SITE_POSITION:\n ret = \"Site positions must be between 0 and sequence_length. \"\n \"(TSK_ERR_BAD_SITE_POSITION)\";\n break;\n\n /* Mutation errors */\n case TSK_ERR_MUTATION_PARENT_DIFFERENT_SITE:\n ret = \"Specified parent mutation is at a different site. \"\n \"(TSK_ERR_MUTATION_PARENT_DIFFERENT_SITE)\";\n break;\n case TSK_ERR_MUTATION_PARENT_EQUAL:\n ret = \"Parent mutation refers to itself. (TSK_ERR_MUTATION_PARENT_EQUAL)\";\n break;\n case TSK_ERR_MUTATION_PARENT_AFTER_CHILD:\n ret = \"Parent mutation ID must be < current ID. \"\n \"(TSK_ERR_MUTATION_PARENT_AFTER_CHILD)\";\n break;\n case TSK_ERR_MUTATION_PARENT_INCONSISTENT:\n ret = \"Mutation parent references form a loop. \"\n \"(TSK_ERR_MUTATION_PARENT_INCONSISTENT)\";\n break;\n case TSK_ERR_UNSORTED_MUTATIONS:\n ret = \"Mutations must be provided in non-decreasing site order and \"\n \"non-increasing time order within each site. \"\n \"(TSK_ERR_UNSORTED_MUTATIONS)\";\n break;\n case TSK_ERR_MUTATION_TIME_YOUNGER_THAN_NODE:\n ret = \"A mutation's time must be >= the node time, or be marked as \"\n \"'unknown'. (TSK_ERR_MUTATION_TIME_YOUNGER_THAN_NODE)\";\n break;\n case TSK_ERR_MUTATION_TIME_OLDER_THAN_PARENT_MUTATION:\n ret = \"A mutation's time must be <= the parent mutation time (if known), or \"\n \"be marked as 'unknown'. \"\n \"(TSK_ERR_MUTATION_TIME_OLDER_THAN_PARENT_MUTATION)\";\n break;\n case TSK_ERR_MUTATION_TIME_OLDER_THAN_PARENT_NODE:\n ret = \"A mutation's time must be < the parent node of the edge on which it \"\n \"occurs, or be marked as 'unknown'. \"\n \"(TSK_ERR_MUTATION_TIME_OLDER_THAN_PARENT_NODE)\";\n break;\n case TSK_ERR_MUTATION_TIME_HAS_BOTH_KNOWN_AND_UNKNOWN:\n ret = \"Mutation times must either be all marked 'unknown', or all be known \"\n \"values for any single site. \"\n \"(TSK_ERR_MUTATION_TIME_HAS_BOTH_KNOWN_AND_UNKNOWN)\";\n break;\n case TSK_ERR_DISALLOWED_UNKNOWN_MUTATION_TIME:\n ret = \"Some mutation times are marked 'unknown' for a method that requires \"\n \"no unknown times. (Use compute_mutation_times to add times?) \"\n \"(TSK_ERR_DISALLOWED_UNKNOWN_MUTATION_TIME)\";\n break;\n\n case TSK_ERR_BAD_MUTATION_PARENT:\n ret = \"A mutation's parent is not consistent with the topology of the tree. \"\n \"Use compute_mutation_parents to set the parents correctly.\"\n \"(TSK_ERR_BAD_MUTATION_PARENT)\";\n break;\n\n /* Migration errors */\n case TSK_ERR_UNSORTED_MIGRATIONS:\n ret = \"Migrations must be sorted by time. (TSK_ERR_UNSORTED_MIGRATIONS)\";\n break;\n\n /* Sample errors */\n case TSK_ERR_DUPLICATE_SAMPLE:\n ret = \"Duplicate sample value. (TSK_ERR_DUPLICATE_SAMPLE)\";\n break;\n case TSK_ERR_BAD_SAMPLES:\n ret = \"The nodes provided are not samples. (TSK_ERR_BAD_SAMPLES)\";\n break;\n\n /* Table errors */\n case TSK_ERR_BAD_TABLE_POSITION:\n ret = \"Bad table position provided to truncate/reset. \"\n \"(TSK_ERR_BAD_TABLE_POSITION)\";\n break;\n case TSK_ERR_BAD_SEQUENCE_LENGTH:\n ret = \"Sequence length must be > 0. (TSK_ERR_BAD_SEQUENCE_LENGTH)\";\n break;\n case TSK_ERR_TABLES_NOT_INDEXED:\n ret = \"Table collection must be indexed. (TSK_ERR_TABLES_NOT_INDEXED)\";\n break;\n case TSK_ERR_TABLES_BAD_INDEXES:\n ret = \"Table collection indexes inconsistent: do they need to be rebuilt? \"\n \"(TSK_ERR_TABLES_BAD_INDEXES)\";\n break;\n case TSK_ERR_TABLE_OVERFLOW:\n ret = \"Table too large; cannot allocate more than 2**31 rows. This error \"\n \"is often caused by a lack of simplification when simulating. \"\n \"(TSK_ERR_TABLE_OVERFLOW)\";\n break;\n case TSK_ERR_COLUMN_OVERFLOW:\n ret = \"Table column too large; cannot be more than 2**64 bytes. \"\n \"(TSK_ERR_COLUMN_OVERFLOW)\";\n break;\n case TSK_ERR_TREE_OVERFLOW:\n ret = \"Too many trees; cannot be more than 2**31. (TSK_ERR_TREE_OVERFLOW)\";\n break;\n case TSK_ERR_METADATA_DISABLED:\n ret = \"Metadata is disabled for this table, so cannot be set. \"\n \"(TSK_ERR_METADATA_DISABLED)\";\n break;\n\n /* Limitations */\n case TSK_ERR_ONLY_INFINITE_SITES:\n ret = \"Only infinite sites mutations are supported for this operation, \"\n \"i.e. at most a single mutation per site. \"\n \"(TSK_ERR_ONLY_INFINITE_SITES)\";\n break;\n case TSK_ERR_SIMPLIFY_MIGRATIONS_NOT_SUPPORTED:\n ret = \"Migrations not currently supported by simplify. \"\n \"(TSK_ERR_SIMPLIFY_MIGRATIONS_NOT_SUPPORTED)\";\n break;\n case TSK_ERR_SORT_MIGRATIONS_NOT_SUPPORTED:\n ret = \"Migrations not currently supported by sort. \"\n \"(TSK_ERR_SORT_MIGRATIONS_NOT_SUPPORTED)\";\n break;\n case TSK_ERR_SORT_OFFSET_NOT_SUPPORTED:\n ret = \"Sort offsets for sites and mutations must be either 0 \"\n \"or the length of the respective tables. Intermediate values \"\n \"are not supported. (TSK_ERR_SORT_OFFSET_NOT_SUPPORTED)\";\n break;\n case TSK_ERR_NONBINARY_MUTATIONS_UNSUPPORTED:\n ret = \"Only binary mutations are supported for this operation. \"\n \"(TSK_ERR_NONBINARY_MUTATIONS_UNSUPPORTED)\";\n break;\n case TSK_ERR_MIGRATIONS_NOT_SUPPORTED:\n ret = \"Migrations not currently supported by this operation. \"\n \"(TSK_ERR_MIGRATIONS_NOT_SUPPORTED)\";\n break;\n case TSK_ERR_CANNOT_EXTEND_FROM_SELF:\n ret = \"Tables can only be extended using rows from a different table. \"\n \"(TSK_ERR_CANNOT_EXTEND_FROM_SELF)\";\n break;\n case TSK_ERR_SILENT_MUTATIONS_NOT_SUPPORTED:\n ret = \"Silent mutations not supported by this operation. \"\n \"(TSK_ERR_SILENT_MUTATIONS_NOT_SUPPORTED)\";\n break;\n case TSK_ERR_VARIANT_CANT_DECODE_COPY:\n ret = \"Can't decode a copy of a variant. (TSK_ERR_VARIANT_CANT_DECODE_COPY)\";\n break;\n case TSK_ERR_CANT_TAKE_OWNERSHIP_NO_EDGE_METADATA:\n ret = \"A tree sequence can't take ownership of tables with \"\n \"TSK_NO_EDGE_METADATA. (TSK_ERR_CANT_TAKE_OWNERSHIP_NO_EDGE_METADATA)\";\n break;\n case TSK_ERR_UNDEFINED_NONBINARY:\n ret = \"Operation undefined for nonbinary trees. \"\n \"(TSK_ERR_UNDEFINED_NONBINARY)\";\n break;\n case TSK_ERR_UNDEFINED_MULTIROOT:\n ret = \"Operation undefined for trees that are not singly-rooted. \"\n \"(TSK_ERR_UNDEFINED_MULTIROOT)\";\n break;\n\n /* Stats errors */\n case TSK_ERR_BAD_NUM_WINDOWS:\n ret = \"Must have at least one window, [0, L]. (TSK_ERR_BAD_NUM_WINDOWS)\";\n break;\n case TSK_ERR_BAD_WINDOWS:\n ret = \"Windows must be increasing list [0, ..., L]. (TSK_ERR_BAD_WINDOWS)\";\n break;\n case TSK_ERR_MULTIPLE_STAT_MODES:\n ret = \"Cannot specify more than one stats mode. \"\n \"(TSK_ERR_MULTIPLE_STAT_MODES)\";\n break;\n case TSK_ERR_BAD_STATE_DIMS:\n ret = \"Must have state dimension >= 1. (TSK_ERR_BAD_STATE_DIMS)\";\n break;\n case TSK_ERR_BAD_RESULT_DIMS:\n ret = \"Must have result dimension >= 1. (TSK_ERR_BAD_RESULT_DIMS)\";\n break;\n case TSK_ERR_INSUFFICIENT_SAMPLE_SETS:\n ret = \"Insufficient sample sets provided. \"\n \"(TSK_ERR_INSUFFICIENT_SAMPLE_SETS)\";\n break;\n case TSK_ERR_INSUFFICIENT_INDEX_TUPLES:\n ret = \"Insufficient sample set index tuples provided. \"\n \"(TSK_ERR_INSUFFICIENT_INDEX_TUPLES)\";\n break;\n case TSK_ERR_BAD_SAMPLE_SET_INDEX:\n ret = \"Sample set index out of bounds. (TSK_ERR_BAD_SAMPLE_SET_INDEX)\";\n break;\n case TSK_ERR_EMPTY_SAMPLE_SET:\n ret = \"Samples cannot be empty. (TSK_ERR_EMPTY_SAMPLE_SET)\";\n break;\n case TSK_ERR_UNSUPPORTED_STAT_MODE:\n ret = \"Requested statistics mode not supported for this method. \"\n \"(TSK_ERR_UNSUPPORTED_STAT_MODE)\";\n break;\n case TSK_ERR_TIME_UNCALIBRATED:\n ret = \"Statistics using branch lengths cannot be calculated when time_units \"\n \"is 'uncalibrated'. (TSK_ERR_TIME_UNCALIBRATED)\";\n break;\n case TSK_ERR_STAT_POLARISED_UNSUPPORTED:\n ret = \"The TSK_STAT_POLARISED option is not supported by this statistic. \"\n \"(TSK_ERR_STAT_POLARISED_UNSUPPORTED)\";\n break;\n case TSK_ERR_STAT_SPAN_NORMALISE_UNSUPPORTED:\n ret = \"The TSK_STAT_SPAN_NORMALISE option is not supported by this \"\n \"statistic. \"\n \"(TSK_ERR_STAT_SPAN_NORMALISE_UNSUPPORTED)\";\n break;\n case TSK_ERR_INSUFFICIENT_WEIGHTS:\n ret = \"Insufficient weights provided (at least 1 required). \"\n \"(TSK_ERR_INSUFFICIENT_WEIGHTS)\";\n break;\n\n /* Pair coalescence errors */\n case TSK_ERR_BAD_NODE_BIN_MAP:\n ret = \"Node-to-bin map contains values less than TSK_NULL. \"\n \"(TSK_ERR_BAD_NODE_BIN_MAP)\";\n break;\n case TSK_ERR_BAD_NODE_BIN_MAP_DIM:\n ret = \"Maximum index in node-to-bin map is greater than the \"\n \"output dimension. (TSK_ERR_BAD_NODE_BIN_MAP_DIM)\";\n break;\n case TSK_ERR_BAD_QUANTILES:\n ret = \"Quantiles must be between 0 and 1 (inclusive) \"\n \"and strictly increasing. (TSK_ERR_BAD_QUANTILES)\";\n break;\n case TSK_ERR_UNSORTED_TIMES:\n ret = \"Times must be strictly increasing. (TSK_ERR_UNSORTED_TIMES)\";\n break;\n case TSK_ERR_BAD_TIME_WINDOWS_DIM:\n ret = \"Must have at least one time window. (TSK_ERR_BAD_TIME_WINDOWS_DIM)\";\n break;\n case TSK_ERR_BAD_SAMPLE_PAIR_TIMES:\n ret = \"All sample times must be equal to the start of first time window. \"\n \"(TSK_ERR_BAD_SAMPLE_PAIR_TIMES)\";\n break;\n case TSK_ERR_BAD_TIME_WINDOWS:\n ret = \"Time windows must start at zero and be strictly increasing. \"\n \"(TSK_ERR_BAD_TIME_WINDOWS)\";\n break;\n case TSK_ERR_BAD_TIME_WINDOWS_END:\n ret = \"Time windows must end at infinity for this method. \"\n \"(TSK_ERR_BAD_TIME_WINDOWS_END)\";\n break;\n case TSK_ERR_BAD_NODE_TIME_WINDOW:\n ret = \"Node time does not fall within assigned time window. \"\n \"(TSK_ERR_BAD_NODE_TIME_WINDOW)\";\n break;\n\n /* Two locus errors */\n case TSK_ERR_STAT_UNSORTED_POSITIONS:\n ret = \"The provided positions are not sorted in strictly increasing \"\n \"order. (TSK_ERR_STAT_UNSORTED_POSITIONS)\";\n break;\n case TSK_ERR_STAT_DUPLICATE_POSITIONS:\n ret = \"The provided positions contain duplicates. \"\n \"(TSK_ERR_STAT_DUPLICATE_POSITIONS)\";\n break;\n case TSK_ERR_STAT_UNSORTED_SITES:\n ret = \"The provided sites are not sorted in strictly increasing position \"\n \"order. (TSK_ERR_STAT_UNSORTED_SITES)\";\n break;\n case TSK_ERR_STAT_DUPLICATE_SITES:\n ret = \"The provided sites contain duplicated entries. \"\n \"(TSK_ERR_STAT_DUPLICATE_SITES)\";\n break;\n\n /* Mutation mapping errors */\n case TSK_ERR_GENOTYPES_ALL_MISSING:\n ret = \"Must provide at least one non-missing genotype. \"\n \"(TSK_ERR_GENOTYPES_ALL_MISSING)\";\n break;\n case TSK_ERR_BAD_GENOTYPE:\n ret = \"Bad genotype value provided. (TSK_ERR_BAD_GENOTYPE)\";\n break;\n case TSK_ERR_BAD_ANCESTRAL_STATE:\n ret = \"Bad ancestral state specified. (TSK_ERR_BAD_ANCESTRAL_STATE)\";\n break;\n\n /* Genotype decoding errors */\n case TSK_ERR_MUST_IMPUTE_NON_SAMPLES:\n ret = \"Cannot generate genotypes for non-samples when isolated nodes are \"\n \"considered as missing. (TSK_ERR_MUST_IMPUTE_NON_SAMPLES)\";\n break;\n case TSK_ERR_ALLELE_NOT_FOUND:\n ret = \"An allele was not found in the user-specified allele map. \"\n \"(TSK_ERR_ALLELE_NOT_FOUND)\";\n break;\n case TSK_ERR_TOO_MANY_ALLELES:\n ret = \"Cannot have more than 2147483647 alleles (TSK_ERR_TOO_MANY_ALLELES)\";\n break;\n case TSK_ERR_ZERO_ALLELES:\n ret = \"Must have at least one allele when specifying an allele map. \"\n \"(TSK_ERR_ZERO_ALLELES)\";\n break;\n case TSK_ERR_BAD_ALLELE_LENGTH:\n ret = \"Alleles used when decoding alignments must have length one. \"\n \"(TSK_ERR_BAD_ALLELE_LENGTH)\";\n break;\n case TSK_ERR_MISSING_CHAR_COLLISION:\n ret = \"Alleles used when decoding alignments must not match the missing \"\n \"data character. (TSK_ERR_MISSING_CHAR_COLLISION)\";\n break;\n\n /* Distance metric errors */\n case TSK_ERR_SAMPLE_SIZE_MISMATCH:\n ret = \"Cannot compare trees with different numbers of samples. \"\n \"(TSK_ERR_SAMPLE_SIZE_MISMATCH)\";\n break;\n case TSK_ERR_SAMPLES_NOT_EQUAL:\n ret = \"Samples must be identical in trees to compare. \"\n \"(TSK_ERR_SAMPLES_NOT_EQUAL)\";\n break;\n case TSK_ERR_MULTIPLE_ROOTS:\n ret = \"Trees with multiple roots not supported. (TSK_ERR_MULTIPLE_ROOTS)\";\n break;\n case TSK_ERR_UNARY_NODES:\n ret = \"Unsimplified trees with unary nodes are not supported. \"\n \"(TSK_ERR_UNARY_NODES)\";\n break;\n case TSK_ERR_SEQUENCE_LENGTH_MISMATCH:\n ret = \"Sequence lengths must be identical to compare. \"\n \"(TSK_ERR_SEQUENCE_LENGTH_MISMATCH)\";\n break;\n case TSK_ERR_NO_SAMPLE_LISTS:\n ret = \"The sample_lists option must be enabled on the tree to perform this \"\n \"operation. Pass the option to the constructor or method that created \"\n \"the tree. (TSK_ERR_NO_SAMPLE_LISTS)\";\n break;\n\n /* Haplotype matching errors */\n case TSK_ERR_NULL_VITERBI_MATRIX:\n ret = \"Viterbi matrix has not filled. (TSK_ERR_NULL_VITERBI_MATRIX)\";\n break;\n case TSK_ERR_MATCH_IMPOSSIBLE:\n ret = \"No matching haplotype exists with current parameters. \"\n \"(TSK_ERR_MATCH_IMPOSSIBLE)\";\n break;\n case TSK_ERR_BAD_COMPRESSED_MATRIX_NODE:\n ret = \"The compressed matrix contains a node that subtends no samples. \"\n \"(TSK_ERR_BAD_COMPRESSED_MATRIX_NODE)\";\n break;\n case TSK_ERR_TOO_MANY_VALUES:\n ret = \"Too many values to compress. (TSK_ERR_TOO_MANY_VALUES)\";\n break;\n\n /* Union errors */\n case TSK_ERR_UNION_BAD_MAP:\n ret = \"Node map contains an entry of a node not present in this table \"\n \"collection. (TSK_ERR_UNION_BAD_MAP)\";\n break;\n case TSK_ERR_UNION_DIFF_HISTORIES:\n // histories could be equivalent, because subset does not reorder\n // edges (if not sorted) or mutations.\n ret = \"Shared portions of the tree sequences are not equal. \"\n \"(TSK_ERR_UNION_DIFF_HISTORIES)\";\n break;\n\n /* IBD errors */\n case TSK_ERR_SAME_NODES_IN_PAIR:\n ret = \"Both nodes in the sample pair are the same. \"\n \"(TSK_ERR_SAME_NODES_IN_PAIR)\";\n break;\n\n case TSK_ERR_IBD_PAIRS_NOT_STORED:\n ret = \"The sample pairs are not stored by default in ibd_segments. Please \"\n \"add the TSK_IBD_STORE_PAIRS option flag if per-pair statistics are \"\n \"required. (TSK_ERR_IBD_PAIRS_NOT_STORED)\";\n break;\n\n case TSK_ERR_IBD_SEGMENTS_NOT_STORED:\n ret = \"All segments are not stored by default in ibd_segments. Please \"\n \"add the TSK_IBD_STORE_SEGMENTS option flag if they are required. \"\n \"(TSK_ERR_IBD_SEGMENTS_NOT_STORED)\";\n break;\n\n /* Simplify errors */\n case TSK_ERR_KEEP_UNARY_MUTUALLY_EXCLUSIVE:\n ret = \"You cannot specify both TSK_SIMPLIFY_KEEP_UNARY and \"\n \"TSK_SIMPLIFY_KEEP_UNARY_IN_INDIVDUALS. \"\n \"(TSK_ERR_KEEP_UNARY_MUTUALLY_EXCLUSIVE)\";\n break;\n\n /* Individual errors */\n case TSK_ERR_UNSORTED_INDIVIDUALS:\n ret = \"Individuals must be provided in an order where children are after \"\n \"their parent individuals (TSK_ERR_UNSORTED_INDIVIDUALS)\";\n break;\n\n case TSK_ERR_INDIVIDUAL_SELF_PARENT:\n ret = \"Individuals cannot be their own parents. \"\n \"(TSK_ERR_INDIVIDUAL_SELF_PARENT)\";\n break;\n\n case TSK_ERR_INDIVIDUAL_PARENT_CYCLE:\n ret = \"Individuals cannot be their own ancestor. \"\n \"(TSK_ERR_INDIVIDUAL_PARENT_CYCLE)\";\n break;\n\n case TSK_ERR_INDIVIDUAL_POPULATION_MISMATCH:\n ret = \"Individual populations cannot be returned \"\n \"if an individual has nodes from more than one population. \"\n \"(TSK_ERR_INDIVIDUAL_POPULATION_MISMATCH)\";\n break;\n\n case TSK_ERR_INDIVIDUAL_TIME_MISMATCH:\n ret = \"Individual times cannot be returned \"\n \"if an individual has nodes from more than one time. \"\n \"(TSK_ERR_INDIVIDUAL_TIME_MISMATCH)\";\n break;\n\n case TSK_ERR_EXTEND_EDGES_BAD_MAXITER:\n ret = \"Maximum number of iterations must be positive. \"\n \"(TSK_ERR_EXTEND_EDGES_BAD_MAXITER)\";\n break;\n }\n return ret;\n}\n\nint\ntsk_set_kas_error(int err)\n{\n if (err == KAS_ERR_IO) {\n /* If we've detected an IO error, report it as TSK_ERR_IO so that we have\n * a consistent error code covering these situtations */\n return TSK_ERR_IO;\n } else {\n /* Flip this bit. As the error is negative, this sets the bit to 0 */\n return err ^ (1 << TSK_KAS_ERR_BIT);\n }\n}\n\nbool\ntsk_is_kas_error(int err)\n{\n return !(err & (1 << TSK_KAS_ERR_BIT));\n}\n\nint\ntsk_get_kas_error(int err)\n{\n return err ^ (1 << TSK_KAS_ERR_BIT);\n}\n\nconst char *\ntsk_strerror(int err)\n{\n if (err != 0 && tsk_is_kas_error(err)) {\n return kas_strerror(tsk_get_kas_error(err));\n } else {\n return tsk_strerror_internal(err);\n }\n}\n\nvoid\n__tsk_safe_free(void **ptr)\n{\n if (ptr != NULL) {\n if (*ptr != NULL) {\n free(*ptr);\n *ptr = NULL;\n }\n }\n}\n\n/* Block allocator. Simple allocator when we lots of chunks of memory\n * and don't need to free them individually.\n */\n\nvoid\ntsk_blkalloc_print_state(tsk_blkalloc_t *self, FILE *out)\n{\n fprintf(out, \"Block allocator%p::\\n\", (void *) self);\n fprintf(out, \"\\ttop = %lld\\n\", (long long) self->top);\n fprintf(out, \"\\tchunk_size = %lld\\n\", (long long) self->chunk_size);\n fprintf(out, \"\\tnum_chunks = %lld\\n\", (long long) self->num_chunks);\n fprintf(out, \"\\ttotal_allocated = %lld\\n\", (long long) self->total_allocated);\n fprintf(out, \"\\ttotal_size = %lld\\n\", (long long) self->total_size);\n}\n\nint TSK_WARN_UNUSED\ntsk_blkalloc_reset(tsk_blkalloc_t *self)\n{\n int ret = 0;\n\n self->top = 0;\n self->current_chunk = 0;\n self->total_allocated = 0;\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_blkalloc_init(tsk_blkalloc_t *self, size_t chunk_size)\n{\n int ret = 0;\n\n tsk_memset(self, 0, sizeof(tsk_blkalloc_t));\n if (chunk_size < 1) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n self->chunk_size = chunk_size;\n self->top = 0;\n self->current_chunk = 0;\n self->total_allocated = 0;\n self->total_size = 0;\n self->num_chunks = 0;\n self->mem_chunks = malloc(sizeof(char *));\n if (self->mem_chunks == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n self->mem_chunks[0] = malloc(chunk_size);\n if (self->mem_chunks[0] == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n self->num_chunks = 1;\n self->total_size = chunk_size + sizeof(void *);\nout:\n return ret;\n}\n\nvoid *TSK_WARN_UNUSED\ntsk_blkalloc_get(tsk_blkalloc_t *self, size_t size)\n{\n void *ret = NULL;\n void *p;\n\n if (size > self->chunk_size) {\n goto out;\n }\n if ((self->top + size) > self->chunk_size) {\n if (self->current_chunk == (self->num_chunks - 1)) {\n p = realloc(self->mem_chunks, (self->num_chunks + 1) * sizeof(void *));\n if (p == NULL) {\n goto out;\n }\n self->mem_chunks = p;\n p = malloc(self->chunk_size);\n if (p == NULL) {\n goto out;\n }\n self->mem_chunks[self->num_chunks] = p;\n self->num_chunks++;\n self->total_size += self->chunk_size + sizeof(void *);\n }\n self->current_chunk++;\n self->top = 0;\n }\n ret = self->mem_chunks[self->current_chunk] + self->top;\n self->top += size;\n self->total_allocated += size;\nout:\n return ret;\n}\n\nvoid\ntsk_blkalloc_free(tsk_blkalloc_t *self)\n{\n size_t j;\n\n for (j = 0; j < self->num_chunks; j++) {\n if (self->mem_chunks[j] != NULL) {\n free(self->mem_chunks[j]);\n }\n }\n if (self->mem_chunks != NULL) {\n free(self->mem_chunks);\n }\n}\n\n/* Mirrors the semantics of numpy's searchsorted function. Uses binary\n * search to find the index of the closest value in the array. */\ntsk_size_t\ntsk_search_sorted(const double *restrict array, tsk_size_t size, double value)\n{\n int64_t upper = (int64_t) size;\n int64_t lower = 0;\n int64_t offset = 0;\n int64_t mid;\n\n if (upper == 0) {\n return 0;\n }\n\n while (upper - lower > 1) {\n mid = (upper + lower) / 2;\n if (value >= array[mid]) {\n lower = mid;\n } else {\n upper = mid;\n }\n }\n offset = (int64_t) (array[lower] < value);\n return (tsk_size_t) (lower + offset);\n}\n\n/* Rounds the specified double to the closest multiple of 10**-num_digits. If\n * num_digits > 22, return value without changes. This is intended for use with\n * small positive numbers; behaviour with large inputs has not been considered.\n *\n * Based on double_round from the Python standard library\n * https://github.com/python/cpython/blob/master/Objects/floatobject.c#L985\n */\ndouble\ntsk_round(double x, unsigned int ndigits)\n{\n double pow1, y, z;\n\n z = x;\n if (ndigits < 22) {\n pow1 = pow(10.0, (double) ndigits);\n y = x * pow1;\n z = round(y);\n if (fabs(y - z) == 0.5) {\n /* halfway between two integers; use round-half-even */\n z = 2.0 * round(y / 2.0);\n }\n z = z / pow1;\n }\n return z;\n}\n\n/* As NANs are not equal, use this function to check for equality to TSK_UNKNOWN_TIME */\nbool\ntsk_is_unknown_time(double val)\n{\n union {\n uint64_t i;\n double f;\n } nan_union;\n nan_union.f = val;\n return nan_union.i == TSK_UNKNOWN_TIME_HEX;\n}\n\n/* Work around a bug which seems to show up on various mixtures of\n * compiler and libc versions, where isfinite and isnan result in\n * spurious warnings about casting down to float. The original issue\n * is here:\n * https://github.com/tskit-dev/tskit/issues/721\n *\n * The simplest approach seems to be to use the builtins where they\n * are available (clang and gcc), and to use the library macro\n * otherwise. There would be no disadvantage to using the builtin\n * version, so there's no real harm in this approach.\n */\n\nbool\ntsk_isnan(double val)\n{\n#if defined(__GNUC__)\n return __builtin_isnan(val);\n#else\n return isnan(val);\n#endif\n}\n\nbool\ntsk_isfinite(double val)\n{\n#if defined(__GNUC__)\n return __builtin_isfinite(val);\n#else\n return isfinite(val);\n#endif\n}\n\nvoid *\ntsk_malloc(tsk_size_t size)\n{\n /* Avoid malloc(0) as it's not portable */\n if (size == 0) {\n size = 1;\n }\n#if TSK_MAX_SIZE > SIZE_MAX\n if (size > SIZE_MAX) {\n return NULL;\n }\n#endif\n return malloc((size_t) size);\n}\n\nvoid *\ntsk_realloc(void *ptr, tsk_size_t size)\n{\n /* We shouldn't ever realloc to a zero size in tskit */\n tsk_bug_assert(size > 0);\n return realloc(ptr, (size_t) size);\n}\n\n/* We keep the size argument here as a size_t because we'd have to\n * cast the outputs of sizeof() otherwise, which would lead to\n * less readable code. We need to be careful to use calloc within\n * the library accordingly, so that size can't overflow on 32 bit.\n */\nvoid *\ntsk_calloc(tsk_size_t n, size_t size)\n{\n /* Avoid calloc(0) as it's not portable */\n if (n == 0) {\n n = 1;\n }\n#if TSK_MAX_SIZE > SIZE_MAX\n if (n > SIZE_MAX) {\n return NULL;\n }\n#endif\n return calloc((size_t) n, size);\n}\n\nvoid *\ntsk_memset(void *ptr, int fill, tsk_size_t size)\n{\n return memset(ptr, fill, (size_t) size);\n}\n\nvoid *\ntsk_memcpy(void *dest, const void *src, tsk_size_t size)\n{\n return memcpy(dest, src, (size_t) size);\n}\n\nvoid *\ntsk_memmove(void *dest, const void *src, tsk_size_t size)\n{\n return memmove(dest, src, (size_t) size);\n}\n\nint\ntsk_memcmp(const void *s1, const void *s2, tsk_size_t size)\n{\n return memcmp(s1, s2, (size_t) size);\n}\n\n/* We can't initialise the stream to its real default value because\n * of limitations on static initialisers. To work around this, we initialise\n * it to NULL and then set the value to the required standard stream\n * when called. */\n\nFILE *_tsk_debug_stream = NULL;\n\nvoid\ntsk_set_debug_stream(FILE *f)\n{\n _tsk_debug_stream = f;\n}\n\nFILE *\ntsk_get_debug_stream(void)\n{\n if (_tsk_debug_stream == NULL) {\n _tsk_debug_stream = TSK_DEFAULT_DEBUG_STREAM;\n }\n return _tsk_debug_stream;\n}\n\n/* AVL Tree implementation. This is based directly on Knuth's implementation\n * in TAOCP. See the python/tests/test_avl_tree.py for more information,\n * and equivalent code annotated with the original algorithm listing.\n */\n\nstatic void\ntsk_avl_tree_int_print_node(tsk_avl_node_int_t *node, int depth, FILE *out)\n{\n int d;\n\n if (node == NULL) {\n return;\n }\n for (d = 0; d < depth; d++) {\n fprintf(out, \" \");\n }\n fprintf(out, \"key=%d balance=%d\\n\", (int) node->key, node->balance);\n tsk_avl_tree_int_print_node(node->llink, depth + 1, out);\n tsk_avl_tree_int_print_node(node->rlink, depth + 1, out);\n}\nvoid\ntsk_avl_tree_int_print_state(tsk_avl_tree_int_t *self, FILE *out)\n{\n fprintf(out, \"AVL tree: size=%d height=%d\\n\", (int) self->size, (int) self->height);\n tsk_avl_tree_int_print_node(self->head.rlink, 0, out);\n}\n\nint\ntsk_avl_tree_int_init(tsk_avl_tree_int_t *self)\n{\n memset(self, 0, sizeof(*self));\n return 0;\n}\n\nint\ntsk_avl_tree_int_free(tsk_avl_tree_int_t *TSK_UNUSED(self))\n{\n return 0;\n}\n\ntsk_avl_node_int_t *\ntsk_avl_tree_int_get_root(const tsk_avl_tree_int_t *self)\n{\n return self->head.rlink;\n}\n\ntsk_avl_node_int_t *\ntsk_avl_tree_int_search(const tsk_avl_tree_int_t *self, int64_t key)\n{\n tsk_avl_node_int_t *P = self->head.rlink;\n\n while (P != NULL) {\n if (key == P->key) {\n break;\n } else if (key < P->key) {\n P = P->llink;\n } else {\n P = P->rlink;\n }\n }\n return P;\n}\n\nstatic int\ntsk_avl_tree_int_insert_empty(tsk_avl_tree_int_t *self, tsk_avl_node_int_t *node)\n{\n self->head.rlink = node;\n self->size = 1;\n self->height = 1;\n node->llink = NULL;\n node->rlink = NULL;\n node->balance = 0;\n return 0;\n}\n\n#define get_link(a, P) ((a) == -1 ? (P)->llink : (P)->rlink)\n#define set_link(a, P, val) \\\n do { \\\n if ((a) == -1) { \\\n (P)->llink = val; \\\n } else { \\\n (P)->rlink = val; \\\n } \\\n } while (0);\n\nstatic int\ntsk_avl_tree_int_insert_non_empty(tsk_avl_tree_int_t *self, tsk_avl_node_int_t *node)\n{\n const int64_t K = node->key;\n tsk_avl_node_int_t *T = &self->head;\n tsk_avl_node_int_t *S = T->rlink;\n tsk_avl_node_int_t *P = T->rlink;\n tsk_avl_node_int_t *Q, *R;\n int a;\n\n while (true) {\n if (K == P->key) {\n /* TODO figure out what the most useful semantics are here. Just\n * returning 1 as a non-zero value for now. */\n return 1;\n } else if (K < P->key) {\n Q = P->llink;\n if (Q == NULL) {\n Q = node;\n P->llink = Q;\n break;\n }\n } else {\n Q = P->rlink;\n if (Q == NULL) {\n Q = node;\n P->rlink = Q;\n break;\n }\n }\n if (Q->balance != 0) {\n T = P;\n S = Q;\n }\n P = Q;\n }\n\n self->size++;\n Q->llink = NULL;\n Q->rlink = NULL;\n Q->balance = 0;\n\n if (K < S->key) {\n a = -1;\n } else {\n a = 1;\n }\n P = get_link(a, S);\n R = P;\n while (P != Q) {\n if (K < P->key) {\n P->balance = -1;\n P = P->llink;\n } else if (K > P->key) {\n P->balance = 1;\n P = P->rlink;\n }\n }\n\n if (S->balance == 0) {\n S->balance = a;\n self->height++;\n } else if (S->balance == -a) {\n S->balance = 0;\n } else {\n if (R->balance == a) {\n P = R;\n set_link(a, S, get_link(-a, R));\n set_link(-a, R, S);\n S->balance = 0;\n R->balance = 0;\n } else if (R->balance == -a) {\n P = get_link(-a, R);\n set_link(-a, R, get_link(a, P));\n set_link(a, P, R);\n set_link(a, S, get_link(-a, P));\n set_link(-a, P, S);\n if (P->balance == a) {\n S->balance = -a;\n R->balance = 0;\n } else if (P->balance == 0) {\n S->balance = 0;\n R->balance = 0;\n } else {\n S->balance = 0;\n R->balance = a;\n }\n P->balance = 0;\n }\n if (S == T->rlink) {\n T->rlink = P;\n } else {\n T->llink = P;\n }\n }\n return 0;\n}\n\nint\ntsk_avl_tree_int_insert(tsk_avl_tree_int_t *self, tsk_avl_node_int_t *node)\n{\n int ret = 0;\n\n if (self->size == 0) {\n ret = tsk_avl_tree_int_insert_empty(self, node);\n } else {\n ret = tsk_avl_tree_int_insert_non_empty(self, node);\n }\n return ret;\n}\n\n/* An inorder traversal of the nodes in an AVL tree (or any binary search tree)\n * yields the keys in sorted order. The recursive implementation is safe here\n * because this is an AVL tree and it is strictly balanced, the depth is very\n * limited. Using GCC's __builtin_frame_address it looks like the size of a stack\n * frame for this function is 48 bytes. Assuming a stack size of 1MiB, this\n * would give us a maximum tree depth of 21845 - so, we're pretty safe.\n */\nstatic int\nordered_nodes_traverse(tsk_avl_node_int_t *node, int index, tsk_avl_node_int_t **out)\n{\n if (node == NULL) {\n return index;\n }\n index = ordered_nodes_traverse(node->llink, index, out);\n out[index] = node;\n return ordered_nodes_traverse(node->rlink, index + 1, out);\n}\n\nint\ntsk_avl_tree_int_ordered_nodes(const tsk_avl_tree_int_t *self, tsk_avl_node_int_t **out)\n{\n ordered_nodes_traverse(self->head.rlink, 0, out);\n return 0;\n}\n\n// Bit Array implementation. Allows us to store unsigned integers in a compact manner.\n// Currently implemented as an array of 32-bit unsigned integers.\n\nint\ntsk_bitset_init(tsk_bitset_t *self, tsk_size_t num_bits, tsk_size_t length)\n{\n int ret = 0;\n\n self->row_len = (num_bits / TSK_BITSET_BITS) + (num_bits % TSK_BITSET_BITS ? 1 : 0);\n self->len = length;\n self->data = tsk_calloc(self->row_len * length, sizeof(*self->data));\n if (self->data == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\nout:\n return ret;\n}\n\n#define BITSET_DATA_ROW(bs, row) ((bs)->data + (row) * (bs)->row_len)\n\nvoid\ntsk_bitset_intersect(const tsk_bitset_t *self, tsk_size_t self_row,\n const tsk_bitset_t *other, tsk_size_t other_row, tsk_bitset_t *out)\n{\n const tsk_bitset_val_t *restrict self_d = BITSET_DATA_ROW(self, self_row);\n const tsk_bitset_val_t *restrict other_d = BITSET_DATA_ROW(other, other_row);\n tsk_bitset_val_t *restrict out_d = out->data;\n for (tsk_size_t i = 0; i < self->row_len; i++) {\n out_d[i] = self_d[i] & other_d[i];\n }\n}\n\nvoid\ntsk_bitset_subtract(tsk_bitset_t *self, tsk_size_t self_row, const tsk_bitset_t *other,\n tsk_size_t other_row)\n{\n tsk_bitset_val_t *restrict self_d = BITSET_DATA_ROW(self, self_row);\n const tsk_bitset_val_t *restrict other_d = BITSET_DATA_ROW(other, other_row);\n for (tsk_size_t i = 0; i < self->row_len; i++) {\n self_d[i] &= ~(other_d[i]);\n }\n}\n\nvoid\ntsk_bitset_union(tsk_bitset_t *self, tsk_size_t self_row, const tsk_bitset_t *other,\n tsk_size_t other_row)\n{\n tsk_bitset_val_t *restrict self_d = BITSET_DATA_ROW(self, self_row);\n const tsk_bitset_val_t *restrict other_d = BITSET_DATA_ROW(other, other_row);\n for (tsk_size_t i = 0; i < self->row_len; i++) {\n self_d[i] |= other_d[i];\n }\n}\n\nvoid\ntsk_bitset_set_bit(tsk_bitset_t *self, tsk_size_t row, const tsk_bitset_val_t bit)\n{\n tsk_bitset_val_t i = (bit / TSK_BITSET_BITS);\n *(BITSET_DATA_ROW(self, row) + i) |= (tsk_bitset_val_t) 1\n << (bit - (TSK_BITSET_BITS * i));\n}\n\nbool\ntsk_bitset_contains(const tsk_bitset_t *self, tsk_size_t row, const tsk_bitset_val_t bit)\n{\n tsk_bitset_val_t i = (bit / TSK_BITSET_BITS);\n return *(BITSET_DATA_ROW(self, row) + i)\n & ((tsk_bitset_val_t) 1 << (bit - (TSK_BITSET_BITS * i)));\n}\n\nstatic inline uint32_t\npopcount(tsk_bitset_val_t v)\n{\n // Utilizes 12 operations per chunk. NB this only works on 32 bit integers.\n // Taken from:\n // https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel\n // There's a nice breakdown of this algorithm here:\n // https://stackoverflow.com/a/109025\n //\n // The gcc/clang compiler flag will -mpopcnt will convert this code to a\n // popcnt instruction (most if not all modern CPUs will support this). The\n // popcnt instruction will yield some speed improvements, which depend on\n // the tree sequence.\n //\n // NB: 32bit counting is typically faster than 64bit counting for this task.\n // (at least on x86-64)\n\n v = v - ((v >> 1) & 0x55555555);\n v = (v & 0x33333333) + ((v >> 2) & 0x33333333);\n return (((v + (v >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;\n}\n\ntsk_size_t\ntsk_bitset_count(const tsk_bitset_t *self, tsk_size_t row)\n{\n tsk_size_t i = 0;\n tsk_size_t count = 0;\n const tsk_bitset_val_t *restrict self_d = BITSET_DATA_ROW(self, row);\n\n for (i = 0; i < self->row_len; i++) {\n count += popcount(self_d[i]);\n }\n return count;\n}\n\nvoid\ntsk_bitset_get_items(\n const tsk_bitset_t *self, tsk_size_t row, tsk_id_t *items, tsk_size_t *n_items)\n{\n // Get the items stored in the row of a bitset.\n // Uses a de Bruijn sequence lookup table to determine the lowest bit set.\n // See the wikipedia article for more info: https://w.wiki/BYiF\n\n tsk_size_t i, n, off;\n tsk_bitset_val_t v, lsb; // least significant bit\n static const tsk_id_t lookup[32] = { 0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25,\n 17, 4, 8, 31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9 };\n const tsk_bitset_val_t *restrict self_d = BITSET_DATA_ROW(self, row);\n\n n = 0;\n for (i = 0; i < self->row_len; i++) {\n v = self_d[i];\n off = i * TSK_BITSET_BITS;\n if (v == 0) {\n continue;\n }\n while ((lsb = v & -v)) {\n items[n] = lookup[(lsb * 0x077cb531U) >> 27] + (tsk_id_t) off;\n n++;\n v ^= lsb;\n }\n }\n *n_items = n;\n}\n\nvoid\ntsk_bitset_free(tsk_bitset_t *self)\n{\n tsk_safe_free(self->data);\n}\n"
},
{
"path": "c/tskit/core.h",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2025 Tskit Developers\n * Copyright (c) 2015-2018 University of Oxford\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n/**\n * @file core.h\n * @brief Core utilities used in all of tskit.\n */\n#ifndef __TSK_CORE_H__\n#define __TSK_CORE_H__\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __GNUC__\n#define TSK_WARN_UNUSED __attribute__((warn_unused_result))\n#define TSK_UNUSED(x) TSK_UNUSED_##x __attribute__((__unused__))\n#else\n#define TSK_WARN_UNUSED\n#define TSK_UNUSED(x) TSK_UNUSED_##x\n/* Don't bother with restrict for MSVC */\n#define restrict\n#endif\n\n/* We assume CHAR_BIT == 8 when loading strings from 8-bit byte arrays */\n#if CHAR_BIT != 8\n#error CHAR_BIT MUST EQUAL 8\n#endif\n\n/* This sets up TSK_DBL_DECIMAL_DIG, which can then be used as a\n * precision specifier when writing out doubles, if you want sufficient\n * decimal digits to be written to guarantee a lossless round-trip\n * after being read back in. Usage:\n *\n * printf(\"%.*g\", TSK_DBL_DECIMAL_DIG, foo);\n *\n * See https://stackoverflow.com/a/19897395/2752221\n */\n#ifdef DBL_DECIMAL_DIG\n#define TSK_DBL_DECIMAL_DIG (DBL_DECIMAL_DIG)\n#else\n#define TSK_DBL_DECIMAL_DIG (DBL_DIG + 3)\n#endif\n\n/**\n@brief Tskit Object IDs.\n\n@rst\nAll objects in tskit are referred to by integer IDs corresponding to the\nrow they occupy in the relevant table. The ``tsk_id_t`` type should be used\nwhen manipulating these ID values. The reserved value :c:macro:`TSK_NULL` (-1) defines\nmissing data.\n@endrst\n*/\n#ifdef _TSK_BIG_TABLES\n/* Allow tables to have more than 2^31 rows. This is an EXPERIMENTAL feature\n * and is not supported in any way. This typedef is only included for\n * future-proofing purposes, so that we can be sure that we don't make any\n * design decisions that are incompatible with big tables by building the\n * library in 64 bit mode in CI. See the discussion here for more background:\n\n * https://github.com/tskit-dev/tskit/issues/343\n *\n * If you need big tables, please open an issue on GitHub to discuss, or comment\n * on the thread above.\n */\ntypedef int64_t tsk_id_t;\n#define TSK_MAX_ID INT64_MAX - 1\n#define TSK_ID_STORAGE_TYPE KAS_INT64\n#else\ntypedef int32_t tsk_id_t;\n#define TSK_MAX_ID INT32_MAX - 1\n#define TSK_ID_STORAGE_TYPE KAS_INT32\n#endif\n\n/**\n@brief Tskit sizes.\n\n@rst\nThe ``tsk_size_t`` type is an unsigned integer used for any size or count value.\n@endrst\n*/\ntypedef uint64_t tsk_size_t;\n#define TSK_MAX_SIZE UINT64_MAX\n#define TSK_SIZE_STORAGE_TYPE KAS_UINT64\n\n/**\n@brief Container for bitwise flags.\n\n@rst\nBitwise flags are used in tskit as a column type and also as a way to\nspecify options to API functions.\n@endrst\n*/\ntypedef uint32_t tsk_flags_t;\n#define TSK_FLAGS_STORAGE_TYPE KAS_UINT32\n\n/**\n@brief Boolean type.\n\n@rst\nFixed-size (1 byte) boolean values.\n@endrst\n*/\ntypedef uint8_t tsk_bool_t;\n\n// clang-format off\n/**\n@defgroup API_VERSION_GROUP API version macros.\n@{\n*/\n/**\nThe library major version. Incremented when breaking changes to the API or ABI are\nintroduced. This includes any changes to the signatures of functions and the\nsizes and types of externally visible structs.\n*/\n#define TSK_VERSION_MAJOR 1\n/**\nThe library minor version. Incremented when non-breaking backward-compatible changes\nto the API or ABI are introduced, i.e., the addition of a new function.\n*/\n#define TSK_VERSION_MINOR 3\n/**\nThe library patch version. Incremented when any changes not relevant to the\nto the API or ABI are introduced, i.e., internal refactors of bugfixes.\n*/\n#define TSK_VERSION_PATCH 1\n/** @} */\n\n/*\nWe define a specific NAN value for default mutation time which indicates\nthe time is unknown. We use a specific value so that if mutation time is set to\na NAN from a computation we can reject it. This specific value is a non-signalling\nNAN with the last six fraction bytes set to the ascii of \"tskit!\"\n*/\n#define TSK_UNKNOWN_TIME_HEX 0x7FF874736B697421ULL\nstatic inline double\n__tsk_nan_f(void)\n{\n const union {\n uint64_t i;\n double f;\n } nan_union = { .i = TSK_UNKNOWN_TIME_HEX };\n return nan_union.f;\n}\n\n/**\n@defgroup GENERIC_CONSTANTS General options flags used in some functions.\n@{\n*/\n/**\nUsed in node flags to indicate that a node is a sample node.\n*/\n#define TSK_NODE_IS_SAMPLE 1u\n\n/**\nNull value used for cases such as absent id references.\n*/\n#define TSK_NULL ((tsk_id_t) -1)\n\n/**\nValue used for missing data in genotype arrays.\n*/\n#define TSK_MISSING_DATA (-1)\n\n/**\nValue to indicate that a time is unknown. Note that this value is a non-signalling NAN\nwhose representation differs from the NAN generated by computations such as divide by zeros.\n*/\n#define TSK_UNKNOWN_TIME __tsk_nan_f()\n\n/** @} */\n\n#define TSK_TIME_UNITS_UNKNOWN \"unknown\"\n#define TSK_TIME_UNITS_UNCALIBRATED \"uncalibrated\"\n\n\n#define TSK_FILE_FORMAT_NAME \"tskit.trees\"\n#define TSK_FILE_FORMAT_NAME_LENGTH 11\n#define TSK_FILE_FORMAT_VERSION_MAJOR 12\n#define TSK_FILE_FORMAT_VERSION_MINOR 7\n\n/**\n@defgroup GENERIC_FUNCTION_OPTIONS General options flags used in some functions.\n@{\n*/\n\n/* Place the common options at the top of the space; this way we can start\noptions for individual functions at the bottom without worrying about\nclashing with the common options\n*/\n\n/** Turn on debugging output. Not supported by all functions. */\n#define TSK_DEBUG (1u << 31)\n\n/** Do not initialise the parameter object. */\n#define TSK_NO_INIT (1u << 30)\n\n/**\nDo not run integrity checks before performing an operation.\nThis performance optimisation should not be used unless the calling code can\nguarantee reference integrity within the table collection. References\nto rows not in the table or bad offsets will result in undefined\nbehaviour.\n*/\n#define TSK_NO_CHECK_INTEGRITY (1u << 29)\n\n/**\nInstead of taking a copy of input objects, the function should take ownership\nof them and manage their lifecycle. The caller specifying this flag should no\nlonger modify or free the object or objects passed. See individual functions\nusing this flag for what object it applies to.\n*/\n#define TSK_TAKE_OWNERSHIP (1u << 28)\n\n/** @} */\n\n\n/**\n@defgroup GENERAL_ERROR_GROUP General errors.\n@{\n*/\n\n/**\nGeneric error thrown when no other message can be generated.\n*/\n#define TSK_ERR_GENERIC -1\n/**\nMemory could not be allocated.\n*/\n#define TSK_ERR_NO_MEMORY -2\n/**\nAn IO error occurred.\n*/\n#define TSK_ERR_IO -3\n#define TSK_ERR_BAD_PARAM_VALUE -4\n#define TSK_ERR_BUFFER_OVERFLOW -5\n#define TSK_ERR_UNSUPPORTED_OPERATION -6\n#define TSK_ERR_GENERATE_UUID -7\n/**\nThe file stream ended after reading zero bytes.\n*/\n#define TSK_ERR_EOF -8\n/** @} */\n\n/**\n@defgroup FILE_FORMAT_ERROR_GROUP File format errors.\n@{\n*/\n\n/**\nA file could not be read because it is in the wrong format\n*/\n#define TSK_ERR_FILE_FORMAT -100\n/**\nThe file is in tskit format, but the version is too old for the\nlibrary to read. The file should be upgraded to the latest version\nusing the ``tskit upgrade`` command line utility from tskit version<0.6.2.\n*/\n#define TSK_ERR_FILE_VERSION_TOO_OLD -101\n/**\nThe file is in tskit format, but the version is too new for the\nlibrary to read. To read the file you must upgrade the version\nof tskit.\n*/\n#define TSK_ERR_FILE_VERSION_TOO_NEW -102\n\n/**\nA column that is a required member of a table was not found in\nthe file.\n*/\n#define TSK_ERR_REQUIRED_COL_NOT_FOUND -103\n\n/**\nOne of a pair of columns that must be specified together was\nnot found in the file.\n*/\n#define TSK_ERR_BOTH_COLUMNS_REQUIRED -104\n\n/**\nAn unsupported type was provided for a column in the file.\n*/\n#define TSK_ERR_BAD_COLUMN_TYPE -105\n/** @} */\n\n/**\n@defgroup OOB_ERROR_GROUP Out of bounds errors.\n@{\n*/\n/**\nA bad value was provided for a ragged column offset, values should\nstart at zero and be monotonically increasing.\n*/\n#define TSK_ERR_BAD_OFFSET -200\n/**\nA position to seek to was less than zero or greater than the length\nof the genome\n*/\n#define TSK_ERR_SEEK_OUT_OF_BOUNDS -201\n/**\nA node id was less than zero or greater than the final index\n*/\n#define TSK_ERR_NODE_OUT_OF_BOUNDS -202\n/**\nA edge id was less than zero or greater than the final index\n*/\n#define TSK_ERR_EDGE_OUT_OF_BOUNDS -203\n/**\nA population id was less than zero or greater than the final index\n*/\n#define TSK_ERR_POPULATION_OUT_OF_BOUNDS -204\n/**\nA site id was less than zero or greater than the final index\n*/\n#define TSK_ERR_SITE_OUT_OF_BOUNDS -205\n/**\nA mutation id was less than zero or greater than the final index\n*/\n#define TSK_ERR_MUTATION_OUT_OF_BOUNDS -206\n/**\nAn individual id was less than zero or greater than the final index\n*/\n#define TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS -207\n/**\nA migration id was less than zero or greater than the final index\n*/\n#define TSK_ERR_MIGRATION_OUT_OF_BOUNDS -208\n/**\nA provenance id was less than zero or greater than the final index\n*/\n#define TSK_ERR_PROVENANCE_OUT_OF_BOUNDS -209\n/**\nA time value was non-finite (NaN counts as finite)\n*/\n#define TSK_ERR_TIME_NONFINITE -210\n/**\nA genomic position was non-finite\n*/\n#define TSK_ERR_GENOME_COORDS_NONFINITE -211\n/**\nOne of the rows in the retained table refers to a row that has been\ndeleted.\n*/\n#define TSK_ERR_KEEP_ROWS_MAP_TO_DELETED -212\n/**\nA genomic position was less than zero or greater equal to the sequence\nlength\n*/\n#define TSK_ERR_POSITION_OUT_OF_BOUNDS -213\n\n/** @} */\n\n/**\n@defgroup EDGE_ERROR_GROUP Edge errors.\n@{\n*/\n/**\nA parent node of an edge was TSK_NULL.\n*/\n#define TSK_ERR_NULL_PARENT -300\n/**\nA child node of an edge was TSK_NULL.\n*/\n#define TSK_ERR_NULL_CHILD -301\n/**\nThe edge table was not sorted by the time of each edge's parent\nnodes. Sort order is (time[parent], child, left).\n*/\n#define TSK_ERR_EDGES_NOT_SORTED_PARENT_TIME -302\n/**\nA parent node had edges that were non-contigious.\n*/\n#define TSK_ERR_EDGES_NONCONTIGUOUS_PARENTS -303\n/**\nThe edge table was not sorted by the id of the child node of each edge.\nSort order is (time[parent], child, left).\n*/\n#define TSK_ERR_EDGES_NOT_SORTED_CHILD -304\n/**\nThe edge table was not sorted by the left coordinate each edge.\nSort order is (time[parent], child, left).\n*/\n#define TSK_ERR_EDGES_NOT_SORTED_LEFT -305\n/**\nAn edge had child node that was older than the parent. Parent times must\nbe greater than the child time.\n*/\n#define TSK_ERR_BAD_NODE_TIME_ORDERING -306\n/**\nAn edge had a genomic interval where right was greater or equal to left.\n*/\n#define TSK_ERR_BAD_EDGE_INTERVAL -307\n/**\nAn edge was duplicated.\n*/\n#define TSK_ERR_DUPLICATE_EDGES -308\n/**\nAn edge had a right coord greater than the genomic length.\n*/\n#define TSK_ERR_RIGHT_GREATER_SEQ_LENGTH -309\n/**\nAn edge had a left coord less than zero.\n*/\n#define TSK_ERR_LEFT_LESS_ZERO -310\n/**\nA parent node had edges that were contradictory over an interval.\n*/\n#define TSK_ERR_BAD_EDGES_CONTRADICTORY_CHILDREN -311\n/**\nA method that doesn't support edge metadata was attempted on an edge\ntable containing metadata.\n*/\n#define TSK_ERR_CANT_PROCESS_EDGES_WITH_METADATA -312\n/** @} */\n\n/**\n@defgroup SITE_ERROR_GROUP Site errors.\n@{\n*/\n/**\nThe site table was not in order of increasing genomic position.\n*/\n#define TSK_ERR_UNSORTED_SITES -400\n/**\nThe site table had more than one site at a single genomic position.\n*/\n#define TSK_ERR_DUPLICATE_SITE_POSITION -401\n/**\nA site had a position that was less than zero or greater than the sequence\nlength.\n*/\n#define TSK_ERR_BAD_SITE_POSITION -402\n/** @} */\n\n/**\n@defgroup MUTATION_ERROR_GROUP Mutation errors.\n@{\n*/\n/**\nA mutation had a parent mutation that was at a different site.\n*/\n#define TSK_ERR_MUTATION_PARENT_DIFFERENT_SITE -500\n/**\nA mutation had a parent mutation that was itself.\n*/\n#define TSK_ERR_MUTATION_PARENT_EQUAL -501\n/**\nA mutation had a parent mutation that had a greater id.\n*/\n#define TSK_ERR_MUTATION_PARENT_AFTER_CHILD -502\n/**\nTwo or more mutation parent references formed a loop\n*/\n#define TSK_ERR_MUTATION_PARENT_INCONSISTENT -503\n/**\nThe mutation table was not in the order of non-decreasing site id and\nnon-increasing time within each site.\n*/\n#define TSK_ERR_UNSORTED_MUTATIONS -504\n/* 505 was the now unused TSK_ERR_NON_SINGLE_CHAR_MUTATION */\n/**\nA mutation's time was younger (not >=) the time of its node\nand wasn't TSK_UNKNOWN_TIME.\n*/\n#define TSK_ERR_MUTATION_TIME_YOUNGER_THAN_NODE -506\n/**\nA mutation's time was older (not <=) than the time of its parent\nmutation, and wasn't TSK_UNKNOWN_TIME.\n*/\n#define TSK_ERR_MUTATION_TIME_OLDER_THAN_PARENT_MUTATION -507\n/**\nA mutation's time was older (not <) than the time of the parent node of\nthe edge on which it occurs, and wasn't TSK_UNKNOWN_TIME.\n*/\n#define TSK_ERR_MUTATION_TIME_OLDER_THAN_PARENT_NODE -508\n/**\nA single site had a mixture of known mutation times and TSK_UNKNOWN_TIME\n*/\n#define TSK_ERR_MUTATION_TIME_HAS_BOTH_KNOWN_AND_UNKNOWN -509\n/**\nSome mutations have TSK_UNKNOWN_TIME in an algorithm where that's\ndisallowed (use compute_mutation_times?).\n*/\n#define TSK_ERR_DISALLOWED_UNKNOWN_MUTATION_TIME -510\n\n/**\nA mutation's parent was not consistent with the topology of the tree.\n */\n#define TSK_ERR_BAD_MUTATION_PARENT -511\n\n/** @} */\n\n/**\n@defgroup MIGRATION_ERROR_GROUP Migration errors.\n@{\n*/\n/**\nThe migration table was not sorted by time.\n*/\n#define TSK_ERR_UNSORTED_MIGRATIONS -550\n/** @} */\n\n/**\n@defgroup SAMPLE_ERROR_GROUP Sample errors.\n@{\n*/\n/**\nA duplicate sample was specified.\n*/\n#define TSK_ERR_DUPLICATE_SAMPLE -600\n/**\nA sample id that was not valid was specified.\n*/\n#define TSK_ERR_BAD_SAMPLES -601\n/** @} */\n\n/**\n@defgroup TABLE_ERROR_GROUP Table errors.\n@{\n*/\n/**\nAn invalid table position was specifed.\n*/\n#define TSK_ERR_BAD_TABLE_POSITION -700\n/**\nA sequence length equal to or less than zero was specified.\n*/\n#define TSK_ERR_BAD_SEQUENCE_LENGTH -701\n/**\nThe table collection was not indexed.\n*/\n#define TSK_ERR_TABLES_NOT_INDEXED -702\n/**\nTables cannot be larger than 2**31 rows.\n*/\n#define TSK_ERR_TABLE_OVERFLOW -703\n/**\nRagged array columns cannot be larger than 2**64 bytes.\n*/\n#define TSK_ERR_COLUMN_OVERFLOW -704\n/**\nThe table collection contains more than 2**31 trees.\n*/\n#define TSK_ERR_TREE_OVERFLOW -705\n/**\nMetadata was attempted to be set on a table where it is disabled.\n*/\n#define TSK_ERR_METADATA_DISABLED -706\n/**\nThere was an error with the table's indexes.\n*/\n#define TSK_ERR_TABLES_BAD_INDEXES -707\n/** @} */\n\n/**\n@defgroup LIMITATION_ERROR_GROUP Limitation errors.\n@{\n*/\n/**\nAn operation was attempted that only supports infinite sites, i.e.\nat most a single mutation per site.\n*/\n#define TSK_ERR_ONLY_INFINITE_SITES -800\n/**\nSimplification was attempted with migrations present, which are not\nsupported.\n*/\n#define TSK_ERR_SIMPLIFY_MIGRATIONS_NOT_SUPPORTED -801\n/**\nSorting was attempted on migrations, which is not supported.\n*/\n#define TSK_ERR_SORT_MIGRATIONS_NOT_SUPPORTED -802\n/**\nAn invalid sort offset was specified, for sites and mutations this must\nbe either 0 or the table length.\n*/\n#define TSK_ERR_SORT_OFFSET_NOT_SUPPORTED -803\n/**\nAn operation was attempted that only supports binary mutations.\n*/\n#define TSK_ERR_NONBINARY_MUTATIONS_UNSUPPORTED -804\n/**\nAn operation was attempted that doesn't support migrations, with a\nnon-empty migration table.\n*/\n#define TSK_ERR_MIGRATIONS_NOT_SUPPORTED -805\n/**\nA table attempted to extend from itself.\n*/\n#define TSK_ERR_CANNOT_EXTEND_FROM_SELF -806\n/**\nAn operation was attempted that doesn't support silent mutations, i.e.\na mutation that doesn't change the allelic state.\n*/\n#define TSK_ERR_SILENT_MUTATIONS_NOT_SUPPORTED -807\n/**\nA copy of a variant cannot be decoded.\n*/\n#define TSK_ERR_VARIANT_CANT_DECODE_COPY -808\n/**\nA tree sequence cannot take ownership of a table collection where\nTSK_NO_EDGE_METADATA.\n*/\n#define TSK_ERR_CANT_TAKE_OWNERSHIP_NO_EDGE_METADATA -809\n/**\nOperation is undefined for nonbinary trees\n*/\n#define TSK_ERR_UNDEFINED_NONBINARY -810\n/**\nOperation is undefined for trees with multiple roots.\n*/\n#define TSK_ERR_UNDEFINED_MULTIROOT -811\n\n/** @} */\n\n/**\n@defgroup STATS_ERROR_GROUP Stats errors.\n@{\n*/\n/**\nZero windows were specified, at least one window must be specified.\n*/\n#define TSK_ERR_BAD_NUM_WINDOWS -900\n/**\nThe window specification was not an increasing list of positions between\n0 and the sequence length.\n*/\n#define TSK_ERR_BAD_WINDOWS -901\n/**\nMore than one stat mode was specified.\n*/\n#define TSK_ERR_MULTIPLE_STAT_MODES -902\n/**\nThe state dimension was not >=1.\n*/\n#define TSK_ERR_BAD_STATE_DIMS -903\n/**\nThe result dimension was not >=1.\n*/\n#define TSK_ERR_BAD_RESULT_DIMS -904\n/**\nInsufficient sample sets were provided.\n*/\n#define TSK_ERR_INSUFFICIENT_SAMPLE_SETS -905\n/**\nInsufficient sample set index tuples were provided.\n*/\n#define TSK_ERR_INSUFFICIENT_INDEX_TUPLES -906\n/**\nThe sample set index was out of bounds.\n*/\n#define TSK_ERR_BAD_SAMPLE_SET_INDEX -907\n/**\nThe sample set index was empty.\n*/\n#define TSK_ERR_EMPTY_SAMPLE_SET -908\n/**\nA stat mode was attempted that is not supported by the operation.\n*/\n#define TSK_ERR_UNSUPPORTED_STAT_MODE -909\n/**\nStatistics based on branch lengths were attempted when the ``time_units``\nwere ``uncalibrated``.\n*/\n#define TSK_ERR_TIME_UNCALIBRATED -910\n/**\nThe TSK_STAT_POLARISED option was passed to a statistic that does\nnot support it.\n*/\n#define TSK_ERR_STAT_POLARISED_UNSUPPORTED -911\n/**\nThe TSK_STAT_SPAN_NORMALISE option was passed to a statistic that does\nnot support it.\n*/\n#define TSK_ERR_STAT_SPAN_NORMALISE_UNSUPPORTED -912\n/**\nInsufficient weights were provided.\n*/\n#define TSK_ERR_INSUFFICIENT_WEIGHTS -913\n/**\nThe node bin map contains a value less than TSK_NULL.\n*/\n#define TSK_ERR_BAD_NODE_BIN_MAP -914\n/**\nMaximum index in node bin map is greater than output dimension.\n*/\n#define TSK_ERR_BAD_NODE_BIN_MAP_DIM -915\n/**\nThe vector of quantiles is out of bounds or in nonascending order.\n*/\n#define TSK_ERR_BAD_QUANTILES -916\n/**\nTimes are not in ascending order\n*/\n#define TSK_ERR_UNSORTED_TIMES -917\n/*\nThe provided positions are not provided in strictly increasing order\n*/\n#define TSK_ERR_STAT_UNSORTED_POSITIONS -918\n/**\nThe provided positions are not unique\n*/\n#define TSK_ERR_STAT_DUPLICATE_POSITIONS -919\n/**\nThe provided sites are not provided in strictly increasing position order\n*/\n#define TSK_ERR_STAT_UNSORTED_SITES -920\n/**\nThe provided sites are not unique\n*/\n#define TSK_ERR_STAT_DUPLICATE_SITES -921\n/**\nThe number of time windows is zero\n*/\n#define TSK_ERR_BAD_TIME_WINDOWS_DIM -922\n/**\nSample times do not all equal the start of first time window\n*/\n#define TSK_ERR_BAD_SAMPLE_PAIR_TIMES -923\n/**\nTime windows are not strictly increasing\n*/\n#define TSK_ERR_BAD_TIME_WINDOWS -924\n/**\nTime windows do not end at infinity\n*/\n#define TSK_ERR_BAD_TIME_WINDOWS_END -925\n/**\nNode time does not fall within assigned time window\n*/\n#define TSK_ERR_BAD_NODE_TIME_WINDOW -926\n/** @} */\n\n/**\n@defgroup MAPPING_ERROR_GROUP Mutation mapping errors.\n@{\n*/\n/**\nOnly missing genotypes were specified, at least one non-missing is\nrequired.\n*/\n#define TSK_ERR_GENOTYPES_ALL_MISSING -1000\n/**\nA genotype value was greater than the maximum allowed (64) or less\nthan TSK_MISSING_DATA (-1).\n*/\n#define TSK_ERR_BAD_GENOTYPE -1001\n/**\nA ancestral genotype value was greater than the maximum allowed (64) or less\nthan 0.\n*/\n#define TSK_ERR_BAD_ANCESTRAL_STATE -1002\n/** @} */\n\n/**\n@defgroup GENOTYPE_ERROR_GROUP Genotype decoding errors.\n@{\n*/\n/**\nGenotypes were requested for non-samples at the same time\nas asking that isolated nodes be marked as missing. This is not\nsupported.\n*/\n#define TSK_ERR_MUST_IMPUTE_NON_SAMPLES -1100\n/**\nA user-specified allele map was used, but didn't contain an allele\nfound in the tree sequence.\n*/\n#define TSK_ERR_ALLELE_NOT_FOUND -1101\n/**\nMore than 2147483647 alleles were specified.\n*/\n#define TSK_ERR_TOO_MANY_ALLELES -1102\n/**\nA user-specified allele map was used, but it contained zero alleles.\n*/\n#define TSK_ERR_ZERO_ALLELES -1103\n/**\nAn allele used when decoding alignments had length other than one.\n*/\n#define TSK_ERR_BAD_ALLELE_LENGTH -1104\n/**\nAn allele used when decoding alignments matched the missing data character.\n*/\n#define TSK_ERR_MISSING_CHAR_COLLISION -1105\n/** @} */\n\n/**\n@defgroup DISTANCE_ERROR_GROUP Distance metric errors.\n@{\n*/\n/**\nTrees with different numbers of samples were specified.\n*/\n#define TSK_ERR_SAMPLE_SIZE_MISMATCH -1200\n/**\nTrees with nonidentical samples were specified.\n*/\n#define TSK_ERR_SAMPLES_NOT_EQUAL -1201\n/**\nA tree with multiple roots was specified.\n*/\n#define TSK_ERR_MULTIPLE_ROOTS -1202\n/**\nA tree with unary nodes was specified.\n*/\n#define TSK_ERR_UNARY_NODES -1203\n/**\nTrees were specifed that had unequal sequence lengths.\n*/\n#define TSK_ERR_SEQUENCE_LENGTH_MISMATCH -1204\n/**\nA tree was specifed that did not have the sample lists option\nenabled (TSK_SAMPLE_LISTS).\n*/\n#define TSK_ERR_NO_SAMPLE_LISTS -1205\n/** @} */\n\n/**\n@defgroup HAPLOTYPE_ERROR_GROUP Haplotype matching errors.\n@{\n*/\n/**\nThe Viterbi matrix has not filled (it has zero transitions).\n*/\n#define TSK_ERR_NULL_VITERBI_MATRIX -1300\n/**\nThere was no matching haplotype.\n*/\n#define TSK_ERR_MATCH_IMPOSSIBLE -1301\n/**\nThe compressed matrix has a node that has no samples in it's descendants.\n*/\n#define TSK_ERR_BAD_COMPRESSED_MATRIX_NODE -1302\n/**\nThere are too many values to compress.\n*/\n#define TSK_ERR_TOO_MANY_VALUES -1303\n/** @} */\n\n/**\n@defgroup UNION_ERROR_GROUP Union errors.\n@{\n*/\n/**\nA node map was specified that contained a node not present in the\nspecified table collection.\n*/\n#define TSK_ERR_UNION_BAD_MAP -1400\n/**\nThe shared portions of the specified tree sequences are not equal.\nNote that this may be the case if the table collections were not\nfully sorted before union was called.\n*/\n#define TSK_ERR_UNION_DIFF_HISTORIES -1401\n/** @} */\n\n/**\n@defgroup IBD_ERROR_GROUP IBD errors.\n@{\n*/\n/**\nBoth nodes in a sample pair are the same node.\n*/\n#define TSK_ERR_SAME_NODES_IN_PAIR -1500\n/**\nPer-pair statistics were requested without TSK_IBD_STORE_PAIRS being\nspecified.\n*/\n#define TSK_ERR_IBD_PAIRS_NOT_STORED -1501\n/**\nSegments were requested without TSK_IBD_STORE_SEGMENTS being specified.\n*/\n#define TSK_ERR_IBD_SEGMENTS_NOT_STORED -1502\n/** @} */\n\n/**\n@defgroup SIMPLIFY_ERROR_GROUP Simplify errors.\n@{\n*/\n/**\nBoth TSK_SIMPLIFY_KEEP_UNARY and TSK_SIMPLIFY_KEEP_UNARY_IN_INDIVIDUALS\nwere specified. Only one can be used.\n*/\n#define TSK_ERR_KEEP_UNARY_MUTUALLY_EXCLUSIVE -1600\n/** @} */\n\n/**\n@defgroup INDIVIDUAL_ERROR_GROUP Individual errors.\n@{\n*/\n/**\nIndividuals were provided in an order where parents were after their\nchildren.\n*/\n#define TSK_ERR_UNSORTED_INDIVIDUALS -1700\n/**\nAn individual was its own parent.\n*/\n#define TSK_ERR_INDIVIDUAL_SELF_PARENT -1701\n/**\nAn individual was its own ancestor in a cycle of references.\n*/\n#define TSK_ERR_INDIVIDUAL_PARENT_CYCLE -1702\n/**\nAn individual had nodes from more than one population\n(and only one was requested).\n*/\n#define TSK_ERR_INDIVIDUAL_POPULATION_MISMATCH -1703\n/**\nAn individual had nodes from more than one time\n(and only one was requested).\n*/\n#define TSK_ERR_INDIVIDUAL_TIME_MISMATCH -1704\n/** @} */\n\n/**\n@defgroup EXTEND_EDGES_ERROR_GROUP Extend edges errors.\n@{\n*/\n/**\nMaximum iteration number (max_iter) must be positive.\n*/\n#define TSK_ERR_EXTEND_EDGES_BAD_MAXITER -1800\n/** @} */\n// clang-format on\n\n/* This bit is 0 for any errors originating from kastore */\n#define TSK_KAS_ERR_BIT 14\n\nint tsk_set_kas_error(int err);\nbool tsk_is_kas_error(int err);\nint tsk_get_kas_error(int err);\n\n/**\n@brief Return a description of the specified error.\n\nThe memory for the returned string is handled by the library and should\nnot be freed by client code.\n\n@param err A tskit error code.\n@return A description of the error.\n*/\nconst char *tsk_strerror(int err);\n\n/* Redefine this macro in downstream builds if stdout is not the\n * approriate stream to emit debug information when the TSK_DEBUG\n * flag is passed to supporting functions (e.g. in R).\n */\n#define TSK_DEFAULT_DEBUG_STREAM stdout\n\n#ifdef TSK_TRACE_ERRORS\n\nstatic inline int\n_tsk_trace_error(int err, int line, const char *file)\n{\n fprintf(stderr, \"tskit-trace-error: %d='%s' at line %d in %s\\n\", err,\n tsk_strerror(err), line, file);\n return err;\n}\n\n/*\nDeveloper note: this macro may be redefined as part of compilation for\nan R package, and should be treated as part of the documented API\n(no changes).\n*/\n#define tsk_trace_error(err) (_tsk_trace_error(err, __LINE__, __FILE__))\n#else\n#define tsk_trace_error(err) (err)\n#endif\n\n#ifndef TSK_BUG_ASSERT_MESSAGE\n#define TSK_BUG_ASSERT_MESSAGE \\\n \"If you are using tskit directly please open an issue on\" \\\n \" GitHub, ideally with a reproducible example.\" \\\n \" (https://github.com/tskit-dev/tskit/issues) If you are\" \\\n \" using software that uses tskit, please report an issue\" \\\n \" to that software's issue tracker, at least initially.\"\n#endif\n\n/**\nWe often wish to assert a condition that is unexpected, but using the normal `assert`\nmeans compiling without NDEBUG. This macro still asserts when NDEBUG is defined.\nIf you are using this macro in your own software then please set TSK_BUG_ASSERT_MESSAGE\nto point users to your issue tracker.\n*/\n/*\nDeveloper note: this macro may redefined as part of compilation for\nan R package, and should be treated as part of the documented API\n(no changes).\n*/\n#define tsk_bug_assert(condition) \\\n do { \\\n if (!(condition)) { \\\n fprintf(stderr, \"Bug detected in %s at line %d. %s\\n\", __FILE__, __LINE__, \\\n TSK_BUG_ASSERT_MESSAGE); \\\n abort(); \\\n } \\\n } while (0)\n\nvoid __tsk_safe_free(void **ptr);\n#define tsk_safe_free(pointer) __tsk_safe_free((void **) &(pointer))\n\n#define TSK_MAX(a, b) ((a) > (b) ? (a) : (b))\n#define TSK_MIN(a, b) ((a) < (b) ? (a) : (b))\n\n/* This is a simple allocator that is optimised to efficiently allocate a\n * large number of small objects without large numbers of calls to malloc.\n * The allocator mallocs memory in chunks of a configurable size. When\n * responding to calls to get(), it will return a chunk of this memory.\n * This memory cannot be subsequently handed back to the allocator. However,\n * all memory allocated by the allocator can be returned at once by calling\n * reset.\n */\n\ntypedef struct {\n size_t chunk_size; /* number of bytes per chunk */\n size_t top; /* the offset of the next available byte in the current chunk */\n size_t current_chunk; /* the index of the chunk currently being used */\n size_t total_size; /* the total number of bytes allocated + overhead. */\n size_t total_allocated; /* the total number of bytes allocated. */\n size_t num_chunks; /* the number of memory chunks. */\n char **mem_chunks; /* the memory chunks */\n} tsk_blkalloc_t;\n\nextern void tsk_blkalloc_print_state(tsk_blkalloc_t *self, FILE *out);\nextern int tsk_blkalloc_reset(tsk_blkalloc_t *self);\nextern int tsk_blkalloc_init(tsk_blkalloc_t *self, size_t chunk_size);\nextern void *tsk_blkalloc_get(tsk_blkalloc_t *self, size_t size);\nextern void tsk_blkalloc_free(tsk_blkalloc_t *self);\n\ntypedef struct _tsk_avl_node_int_t {\n int64_t key;\n void *value;\n struct _tsk_avl_node_int_t *llink;\n struct _tsk_avl_node_int_t *rlink;\n /* This can only contain -1, 0, 1. We could set it to a smaller type,\n * but there's no point because of struct padding and alignment so\n * it's simplest to keep it as a plain int. */\n int balance;\n} tsk_avl_node_int_t;\n\ntypedef struct {\n tsk_avl_node_int_t head;\n tsk_size_t size;\n tsk_size_t height;\n} tsk_avl_tree_int_t;\n\nint tsk_avl_tree_int_init(tsk_avl_tree_int_t *self);\nint tsk_avl_tree_int_free(tsk_avl_tree_int_t *self);\nvoid tsk_avl_tree_int_print_state(tsk_avl_tree_int_t *self, FILE *out);\nint tsk_avl_tree_int_insert(tsk_avl_tree_int_t *self, tsk_avl_node_int_t *node);\ntsk_avl_node_int_t *tsk_avl_tree_int_search(const tsk_avl_tree_int_t *self, int64_t key);\nint tsk_avl_tree_int_ordered_nodes(\n const tsk_avl_tree_int_t *self, tsk_avl_node_int_t **out);\ntsk_avl_node_int_t *tsk_avl_tree_int_get_root(const tsk_avl_tree_int_t *self);\n\ntsk_size_t tsk_search_sorted(const double *array, tsk_size_t size, double value);\n\ndouble tsk_round(double x, unsigned int ndigits);\n\n/**\n@brief Check if a number is ``TSK_UNKNOWN_TIME``\n\n@rst\nUnknown time values in tskit are represented by a particular NaN value. Since NaN values\nare not equal to each other by definition, a simple comparison like\n``mutation.time == TSK_UNKNOWN_TIME`` will fail even if the mutation's time is\nTSK_UNKNOWN_TIME. This function compares the underlying bit representation of a double\nvalue and returns true iff it is equal to the specific NaN value\n:c:macro:`TSK_UNKNOWN_TIME`.\n@endrst\n\n@param val The number to check\n@return true if the number is ``TSK_UNKNOWN_TIME`` else false\n*/\nbool tsk_is_unknown_time(double val);\n\n/* We define local versions of isnan and isfinite to workaround some portability\n * issues. */\nbool tsk_isnan(double val);\nbool tsk_isfinite(double val);\n\n#define TSK_UUID_SIZE 36\nint tsk_generate_uuid(char *dest, int flags);\n\n/* TODO most of these can probably be macros so they compile out as no-ops.\n * Lets do the 64 bit tsk_size_t switch first though. */\nvoid *tsk_malloc(tsk_size_t size);\nvoid *tsk_realloc(void *ptr, tsk_size_t size);\nvoid *tsk_calloc(tsk_size_t n, size_t size);\nvoid *tsk_memset(void *ptr, int fill, tsk_size_t size);\nvoid *tsk_memcpy(void *dest, const void *src, tsk_size_t size);\nvoid *tsk_memmove(void *dest, const void *src, tsk_size_t size);\nint tsk_memcmp(const void *s1, const void *s2, tsk_size_t size);\n\n/* Developer debug utilities. These are **not** threadsafe */\nvoid tsk_set_debug_stream(FILE *f);\nFILE *tsk_get_debug_stream(void);\n\n/* Bit Array functionality */\n\n// define a 32-bit chunk size for our bitsets.\n// this means we'll be able to hold 32 distinct items in each 32 bit uint\n#define TSK_BITSET_BITS ((tsk_size_t) 32)\ntypedef uint32_t tsk_bitset_val_t;\n\ntypedef struct {\n tsk_size_t row_len; // Number of size TSK_BITSET_BITS chunks per row\n tsk_size_t len; // Number of rows\n tsk_bitset_val_t *data;\n} tsk_bitset_t;\n\nint tsk_bitset_init(tsk_bitset_t *self, tsk_size_t num_bits, tsk_size_t length);\nvoid tsk_bitset_free(tsk_bitset_t *self);\nvoid tsk_bitset_intersect(const tsk_bitset_t *self, tsk_size_t self_row,\n const tsk_bitset_t *other, tsk_size_t other_row, tsk_bitset_t *out);\nvoid tsk_bitset_subtract(tsk_bitset_t *self, tsk_size_t self_row,\n const tsk_bitset_t *other, tsk_size_t other_row);\nvoid tsk_bitset_union(tsk_bitset_t *self, tsk_size_t self_row, const tsk_bitset_t *other,\n tsk_size_t other_row);\nvoid tsk_bitset_set_bit(tsk_bitset_t *self, tsk_size_t row, const tsk_bitset_val_t bit);\nbool tsk_bitset_contains(\n const tsk_bitset_t *self, tsk_size_t row, const tsk_bitset_val_t bit);\ntsk_size_t tsk_bitset_count(const tsk_bitset_t *self, tsk_size_t row);\nvoid tsk_bitset_get_items(\n const tsk_bitset_t *self, tsk_size_t row, tsk_id_t *items, tsk_size_t *n_items);\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif\n"
},
{
"path": "c/tskit/genotypes.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2025 Tskit Developers\n * Copyright (c) 2016-2018 University of Oxford\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n\n/* ======================================================== *\n * Variant generator\n * ======================================================== */\n\nvoid\ntsk_variant_print_state(const tsk_variant_t *self, FILE *out)\n{\n tsk_size_t j;\n\n fprintf(out, \"tsk_variant state\\n\");\n fprintf(out, \"user_alleles = %lld\\n\", (long long) self->user_alleles);\n fprintf(out, \"num_alleles = %lld\\n\", (long long) self->num_alleles);\n for (j = 0; j < self->num_alleles; j++) {\n fprintf(out, \"\\tlen = %lld, '%.*s'\\n\", (long long) self->allele_lengths[j],\n (int) self->allele_lengths[j], self->alleles[j]);\n }\n fprintf(out, \"num_samples = %lld\\n\", (long long) self->num_samples);\n}\n\nvoid\ntsk_vargen_print_state(const tsk_vargen_t *self, FILE *out)\n{\n tsk_variant_print_state(&self->variant, out);\n}\n\n/* Copy the fixed allele mapping specified by the user into local\n * memory. */\nstatic int\ntsk_variant_copy_alleles(tsk_variant_t *self, const char **alleles)\n{\n int ret = 0;\n tsk_size_t j;\n size_t total_len, allele_len, offset;\n\n self->num_alleles = self->max_alleles;\n\n total_len = 0;\n for (j = 0; j < self->num_alleles; j++) {\n allele_len = strlen(alleles[j]);\n self->allele_lengths[j] = (tsk_size_t) allele_len;\n total_len += allele_len;\n }\n self->user_alleles_mem = tsk_malloc(total_len * sizeof(char *));\n if (self->user_alleles_mem == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n offset = 0;\n for (j = 0; j < self->num_alleles; j++) {\n strcpy(self->user_alleles_mem + offset, alleles[j]);\n self->alleles[j] = self->user_alleles_mem + offset;\n offset += (size_t) self->allele_lengths[j];\n }\nout:\n return ret;\n}\n\nstatic int\nvariant_init_samples_and_index_map(tsk_variant_t *self,\n const tsk_treeseq_t *tree_sequence, const tsk_id_t *samples, tsk_size_t num_samples,\n size_t num_samples_alloc, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_size_t j, num_nodes;\n tsk_id_t u;\n\n num_nodes = tsk_treeseq_get_num_nodes(tree_sequence);\n self->alt_samples = tsk_malloc(num_samples_alloc * sizeof(*samples));\n self->alt_sample_index_map\n = tsk_malloc(num_nodes * sizeof(*self->alt_sample_index_map));\n if (self->alt_samples == NULL || self->alt_sample_index_map == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memcpy(self->alt_samples, samples, num_samples * sizeof(*samples));\n tsk_memset(self->alt_sample_index_map, 0xff,\n num_nodes * sizeof(*self->alt_sample_index_map));\n /* Create the reverse mapping */\n for (j = 0; j < num_samples; j++) {\n u = samples[j];\n if (u < 0 || u >= (tsk_id_t) num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n if (self->alt_sample_index_map[u] != TSK_NULL) {\n ret = tsk_trace_error(TSK_ERR_DUPLICATE_SAMPLE);\n goto out;\n }\n self->alt_sample_index_map[samples[j]] = (tsk_id_t) j;\n }\nout:\n return ret;\n}\n\nint\ntsk_variant_init(tsk_variant_t *self, const tsk_treeseq_t *tree_sequence,\n const tsk_id_t *samples, tsk_size_t num_samples, const char **alleles,\n tsk_flags_t options)\n{\n int ret = 0;\n tsk_size_t max_alleles_limit, max_alleles;\n tsk_size_t num_samples_alloc;\n\n tsk_memset(self, 0, sizeof(tsk_variant_t));\n\n /* Set site id to NULL to indicate the variant is not decoded */\n self->site.id = TSK_NULL;\n\n self->tree_sequence = tree_sequence;\n ret = tsk_tree_init(\n &self->tree, tree_sequence, samples == NULL ? TSK_SAMPLE_LISTS : 0);\n if (ret != 0) {\n goto out;\n }\n\n if (samples != NULL) {\n /* Take a copy of the samples so we don't have to manage the lifecycle*/\n self->samples = tsk_malloc(num_samples * sizeof(*samples));\n if (self->samples == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memcpy(self->samples, samples, num_samples * sizeof(*samples));\n self->num_samples = num_samples;\n }\n\n self->options = options;\n\n max_alleles_limit = INT32_MAX;\n\n if (alleles == NULL) {\n self->user_alleles = false;\n max_alleles = 4; /* Arbitrary --- we'll rarely have more than this */\n } else {\n self->user_alleles = true;\n /* Count the input alleles. The end is designated by the NULL sentinel. */\n for (max_alleles = 0; alleles[max_alleles] != NULL; max_alleles++)\n ;\n if (max_alleles > max_alleles_limit) {\n ret = tsk_trace_error(TSK_ERR_TOO_MANY_ALLELES);\n goto out;\n }\n if (max_alleles == 0) {\n ret = tsk_trace_error(TSK_ERR_ZERO_ALLELES);\n goto out;\n }\n }\n self->max_alleles = max_alleles;\n self->alleles = tsk_calloc(max_alleles, sizeof(*self->alleles));\n self->allele_lengths = tsk_malloc(max_alleles * sizeof(*self->allele_lengths));\n if (self->alleles == NULL || self->allele_lengths == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n if (self->user_alleles) {\n ret = tsk_variant_copy_alleles(self, alleles);\n if (ret != 0) {\n goto out;\n }\n }\n if (self->samples == NULL) {\n self->num_samples = tsk_treeseq_get_num_samples(tree_sequence);\n self->samples = tsk_malloc(self->num_samples * sizeof(*self->samples));\n if (self->samples == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memcpy(self->samples, tsk_treeseq_get_samples(tree_sequence),\n self->num_samples * sizeof(*self->samples));\n\n self->sample_index_map = tsk_treeseq_get_sample_index_map(tree_sequence);\n num_samples_alloc = self->num_samples;\n } else {\n num_samples_alloc = self->num_samples;\n ret = variant_init_samples_and_index_map(self, tree_sequence, self->samples,\n self->num_samples, (size_t) num_samples_alloc, self->options);\n if (ret != 0) {\n goto out;\n }\n self->sample_index_map = self->alt_sample_index_map;\n }\n /* When a list of samples is given, we use the traversal based algorithm\n * which doesn't use sample list tracking in the tree */\n if (self->alt_samples != NULL) {\n self->traversal_stack = tsk_malloc(\n tsk_treeseq_get_num_nodes(tree_sequence) * sizeof(*self->traversal_stack));\n if (self->traversal_stack == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n }\n\n self->genotypes = tsk_malloc(num_samples_alloc * sizeof(*self->genotypes));\n if (self->genotypes == NULL || self->alleles == NULL\n || self->allele_lengths == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\nout:\n return ret;\n}\n\nint\ntsk_vargen_init(tsk_vargen_t *self, const tsk_treeseq_t *tree_sequence,\n const tsk_id_t *samples, tsk_size_t num_samples, const char **alleles,\n tsk_flags_t options)\n{\n int ret = 0;\n\n tsk_bug_assert(tree_sequence != NULL);\n tsk_memset(self, 0, sizeof(tsk_vargen_t));\n\n self->tree_sequence = tree_sequence;\n ret = tsk_variant_init(\n &self->variant, tree_sequence, samples, num_samples, alleles, options);\n if (ret != 0) {\n goto out;\n }\n ret = 0;\nout:\n return ret;\n}\n\nint\ntsk_variant_free(tsk_variant_t *self)\n{\n if (self->tree_sequence != NULL) {\n tsk_tree_free(&self->tree);\n }\n tsk_safe_free(self->genotypes);\n tsk_safe_free(self->alleles);\n tsk_safe_free(self->allele_lengths);\n tsk_safe_free(self->user_alleles_mem);\n tsk_safe_free(self->samples);\n tsk_safe_free(self->alt_samples);\n tsk_safe_free(self->alt_sample_index_map);\n tsk_safe_free(self->traversal_stack);\n return 0;\n}\n\nint\ntsk_vargen_free(tsk_vargen_t *self)\n{\n tsk_variant_free(&self->variant);\n return 0;\n}\n\nstatic int\ntsk_variant_expand_alleles(tsk_variant_t *self)\n{\n int ret = 0;\n void *p;\n tsk_size_t hard_limit = INT32_MAX;\n\n if (self->max_alleles == hard_limit) {\n ret = tsk_trace_error(TSK_ERR_TOO_MANY_ALLELES);\n goto out;\n }\n self->max_alleles = TSK_MIN(hard_limit, self->max_alleles * 2);\n p = tsk_realloc(self->alleles, self->max_alleles * sizeof(*self->alleles));\n if (p == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n self->alleles = p;\n p = tsk_realloc(\n self->allele_lengths, self->max_alleles * sizeof(*self->allele_lengths));\n if (p == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n self->allele_lengths = p;\nout:\n return ret;\n}\n\n/* The following pair of functions are identical except one handles 8 bit\n * genotypes and the other handles 16 bit genotypes. This is done for performance\n * reasons as this is a key function and for common alleles can entail\n * iterating over millions of samples. The compiler hints are included for the\n * same reason.\n */\nstatic int TSK_WARN_UNUSED\ntsk_variant_update_genotypes_sample_list(\n tsk_variant_t *self, tsk_id_t node, tsk_id_t derived)\n{\n int32_t *restrict genotypes = self->genotypes;\n const tsk_id_t *restrict list_left = self->tree.left_sample;\n const tsk_id_t *restrict list_right = self->tree.right_sample;\n const tsk_id_t *restrict list_next = self->tree.next_sample;\n tsk_id_t index, stop;\n int ret = 0;\n\n tsk_bug_assert(derived < INT32_MAX);\n\n index = list_left[node];\n if (index != TSK_NULL) {\n stop = list_right[node];\n while (true) {\n\n ret += genotypes[index] == TSK_MISSING_DATA;\n genotypes[index] = (int32_t) derived;\n if (index == stop) {\n break;\n }\n index = list_next[index];\n }\n }\n\n return ret;\n}\n\n/* The following functions implement the genotype setting by traversing\n * down the tree to the samples. We're not so worried about performance here\n * because this should only be used when we have a very small number of samples,\n * and so we use a visit function to avoid duplicating code.\n */\n\ntypedef int (*visit_func_t)(tsk_variant_t *, tsk_id_t, tsk_id_t);\n\nstatic int TSK_WARN_UNUSED\ntsk_variant_traverse(\n tsk_variant_t *self, tsk_id_t node, tsk_id_t derived, visit_func_t visit)\n{\n int ret = 0;\n tsk_id_t *restrict stack = self->traversal_stack;\n const tsk_id_t *restrict left_child = self->tree.left_child;\n const tsk_id_t *restrict right_sib = self->tree.right_sib;\n const tsk_id_t *restrict sample_index_map = self->sample_index_map;\n tsk_id_t u, v, sample_index;\n int stack_top;\n int no_longer_missing = 0;\n\n stack_top = 0;\n stack[0] = node;\n while (stack_top >= 0) {\n u = stack[stack_top];\n sample_index = sample_index_map[u];\n if (sample_index != TSK_NULL) {\n ret = visit(self, sample_index, derived);\n if (ret < 0) {\n goto out;\n }\n no_longer_missing += ret;\n }\n stack_top--;\n for (v = left_child[u]; v != TSK_NULL; v = right_sib[v]) {\n stack_top++;\n stack[stack_top] = v;\n }\n }\n ret = no_longer_missing;\nout:\n return ret;\n}\n\nstatic int\ntsk_variant_visit(tsk_variant_t *self, tsk_id_t sample_index, tsk_id_t derived)\n{\n int ret = 0;\n int32_t *restrict genotypes = self->genotypes;\n\n tsk_bug_assert(derived < INT32_MAX);\n tsk_bug_assert(sample_index != -1);\n\n ret = genotypes[sample_index] == TSK_MISSING_DATA;\n genotypes[sample_index] = (int32_t) derived;\n\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_variant_update_genotypes_traversal(\n tsk_variant_t *self, tsk_id_t node, tsk_id_t derived)\n{\n return tsk_variant_traverse(self, node, derived, tsk_variant_visit);\n}\n\nstatic tsk_size_t\ntsk_variant_mark_missing(tsk_variant_t *self)\n{\n tsk_size_t num_missing = 0;\n const tsk_id_t *restrict left_child = self->tree.left_child;\n const tsk_id_t *restrict right_sib = self->tree.right_sib;\n const tsk_id_t *restrict sample_index_map = self->sample_index_map;\n const tsk_id_t N = self->tree.virtual_root;\n int32_t *restrict genotypes = self->genotypes;\n tsk_id_t root, sample_index;\n\n for (root = left_child[N]; root != TSK_NULL; root = right_sib[root]) {\n if (left_child[root] == TSK_NULL) {\n sample_index = sample_index_map[root];\n if (sample_index != TSK_NULL) {\n genotypes[sample_index] = TSK_MISSING_DATA;\n num_missing++;\n }\n }\n }\n return num_missing;\n}\n\n/* Mark missing for any requested node (sample or non-sample) that is isolated\n * in the current tree, i.e., has no parent and no children at this position. */\nstatic tsk_size_t\ntsk_variant_mark_missing_any(tsk_variant_t *self)\n{\n tsk_size_t num_missing = 0;\n int32_t *restrict genotypes = self->genotypes;\n const tsk_id_t *restrict parent = self->tree.parent;\n const tsk_id_t *restrict left_child = self->tree.left_child;\n tsk_size_t j;\n\n for (j = 0; j < self->num_samples; j++) {\n tsk_id_t u = self->samples[j];\n if (parent[u] == TSK_NULL && left_child[u] == TSK_NULL) {\n genotypes[j] = TSK_MISSING_DATA;\n num_missing++;\n }\n }\n return num_missing;\n}\n\nstatic tsk_id_t\ntsk_variant_get_allele_index(tsk_variant_t *self, const char *allele, tsk_size_t length)\n{\n tsk_id_t ret = -1;\n tsk_size_t j;\n\n for (j = 0; j < self->num_alleles; j++) {\n if (length == self->allele_lengths[j]\n && tsk_memcmp(allele, self->alleles[j], length) == 0) {\n ret = (tsk_id_t) j;\n break;\n }\n }\n return ret;\n}\n\nint\ntsk_variant_decode(\n tsk_variant_t *self, tsk_id_t site_id, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_id_t allele_index;\n tsk_size_t j, num_missing;\n int no_longer_missing;\n tsk_mutation_t mutation;\n bool impute_missing = !!(self->options & TSK_ISOLATED_NOT_MISSING);\n bool by_traversal = self->alt_samples != NULL;\n int (*update_genotypes)(tsk_variant_t *, tsk_id_t, tsk_id_t);\n tsk_size_t (*mark_missing)(tsk_variant_t *);\n\n if (self->tree_sequence == NULL) {\n ret = tsk_trace_error(TSK_ERR_VARIANT_CANT_DECODE_COPY);\n goto out;\n }\n\n ret = tsk_treeseq_get_site(self->tree_sequence, site_id, &self->site);\n if (ret != 0) {\n goto out;\n }\n\n ret = tsk_tree_seek(&self->tree, self->site.position, 0);\n if (ret != 0) {\n goto out;\n }\n\n /* When we have no specified samples we need sample lists to be active\n * on the tree, as indicated by the presence of left_sample */\n if (!by_traversal && self->tree.left_sample == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_SAMPLE_LISTS);\n goto out;\n }\n\n /* For now we use a traversal method to find genotypes when we have a\n * specified set of samples, but we should provide the option to do it\n * via tracked_samples in the tree also. There will be a tradeoff: if\n * we only have a small number of samples, it's probably better to\n * do it by traversal. For large sets of samples though, it may be\n * better to use the sample list infrastructure. */\n\n mark_missing = tsk_variant_mark_missing;\n update_genotypes = tsk_variant_update_genotypes_sample_list;\n if (by_traversal) {\n update_genotypes = tsk_variant_update_genotypes_traversal;\n /* When decoding a user-provided list of nodes (which may include\n * non-samples), mark isolated nodes as missing directly by checking\n * isolation status for each requested node. */\n mark_missing = tsk_variant_mark_missing_any;\n }\n\n if (self->user_alleles) {\n allele_index = tsk_variant_get_allele_index(\n self, self->site.ancestral_state, self->site.ancestral_state_length);\n if (allele_index == -1) {\n ret = tsk_trace_error(TSK_ERR_ALLELE_NOT_FOUND);\n goto out;\n }\n } else {\n /* Ancestral state is always allele 0 */\n self->alleles[0] = self->site.ancestral_state;\n self->allele_lengths[0] = self->site.ancestral_state_length;\n self->num_alleles = 1;\n allele_index = 0;\n }\n\n /* The algorithm for generating the allelic state of every sample works by\n * examining each mutation in order, and setting the state for all the\n * samples under the mutation's node. For complex sites where there is\n * more than one mutation, we depend on the ordering of mutations being\n * correct. Specifically, any mutation that is above another mutation in\n * the tree must be visited first. This is enforced using the mutation.parent\n * field, where we require that a mutation's parent must appear before it\n * in the list of mutations. This guarantees the correctness of this algorithm.\n */\n for (j = 0; j < self->num_samples; j++) {\n self->genotypes[j] = (int32_t) allele_index;\n }\n\n /* We mark missing data *before* updating the genotypes because\n * mutations directly over samples should not be missing */\n num_missing = 0;\n if (!impute_missing) {\n num_missing = mark_missing(self);\n }\n for (j = 0; j < self->site.mutations_length; j++) {\n mutation = self->site.mutations[j];\n /* Compute the allele index for this derived state value. */\n allele_index = tsk_variant_get_allele_index(\n self, mutation.derived_state, mutation.derived_state_length);\n if (allele_index == -1) {\n if (self->user_alleles) {\n ret = tsk_trace_error(TSK_ERR_ALLELE_NOT_FOUND);\n goto out;\n }\n if (self->num_alleles == self->max_alleles) {\n ret = tsk_variant_expand_alleles(self);\n if (ret != 0) {\n goto out;\n }\n }\n allele_index = (tsk_id_t) self->num_alleles;\n self->alleles[allele_index] = mutation.derived_state;\n self->allele_lengths[allele_index] = mutation.derived_state_length;\n self->num_alleles++;\n }\n\n no_longer_missing = update_genotypes(self, mutation.node, allele_index);\n if (no_longer_missing < 0) {\n ret = no_longer_missing;\n goto out;\n }\n /* Update genotypes returns the number of missing values marked\n * not-missing */\n num_missing -= (tsk_size_t) no_longer_missing;\n }\n self->has_missing_data = num_missing > 0;\nout:\n return ret;\n}\n\nint\ntsk_variant_restricted_copy(const tsk_variant_t *self, tsk_variant_t *other)\n{\n int ret = 0;\n tsk_size_t total_len, offset, j;\n\n /* Copy everything */\n tsk_memcpy(other, self, sizeof(*other));\n /* Tree sequence left as NULL and zero'd tree is a way of indicating this variant is\n * fixed and cannot be further decoded. */\n other->tree_sequence = NULL;\n tsk_memset(&other->tree, sizeof(other->tree), 0);\n other->traversal_stack = NULL;\n other->samples = NULL;\n other->sample_index_map = NULL;\n other->alt_samples = NULL;\n other->alt_sample_index_map = NULL;\n other->user_alleles_mem = NULL;\n\n total_len = 0;\n for (j = 0; j < self->num_alleles; j++) {\n total_len += self->allele_lengths[j];\n }\n other->samples = tsk_malloc(other->num_samples * sizeof(*other->samples));\n other->genotypes = tsk_malloc(other->num_samples * sizeof(*other->genotypes));\n other->user_alleles_mem = tsk_malloc(total_len * sizeof(*other->user_alleles_mem));\n other->allele_lengths\n = tsk_malloc(other->num_alleles * sizeof(*other->allele_lengths));\n other->alleles = tsk_malloc(other->num_alleles * sizeof(*other->alleles));\n if (other->samples == NULL || other->genotypes == NULL\n || other->user_alleles_mem == NULL || other->allele_lengths == NULL\n || other->alleles == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memcpy(\n other->samples, self->samples, other->num_samples * sizeof(*other->samples));\n tsk_memcpy(other->genotypes, self->genotypes,\n other->num_samples * sizeof(*other->genotypes));\n tsk_memcpy(other->allele_lengths, self->allele_lengths,\n other->num_alleles * sizeof(*other->allele_lengths));\n offset = 0;\n for (j = 0; j < other->num_alleles; j++) {\n tsk_memcpy(other->user_alleles_mem + offset, self->alleles[j],\n other->allele_lengths[j] * sizeof(*other->user_alleles_mem));\n other->alleles[j] = other->user_alleles_mem + offset;\n offset += other->allele_lengths[j];\n }\n\nout:\n return ret;\n}\n\nint\ntsk_vargen_next(tsk_vargen_t *self, tsk_variant_t **variant)\n{\n int ret = 0;\n\n if ((tsk_size_t) self->site_index < tsk_treeseq_get_num_sites(self->tree_sequence)) {\n ret = tsk_variant_decode(&self->variant, self->site_index, 0);\n if (ret != 0) {\n goto out;\n }\n self->site_index++;\n *variant = &self->variant;\n ret = 1;\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_treeseq_decode_alignments_overlay_missing(const tsk_treeseq_t *self,\n const tsk_id_t *nodes, tsk_size_t num_nodes, double left, double right,\n char missing_data_character, tsk_size_t L, char *alignments_out)\n{\n int ret = 0;\n tsk_tree_t tree;\n tsk_size_t i, seg_left, seg_right;\n char *row = NULL;\n tsk_id_t u;\n\n tsk_memset(&tree, 0, sizeof(tree));\n\n ret = tsk_tree_init(&tree, self, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_tree_seek(&tree, left, 0);\n if (ret != 0) {\n goto out;\n }\n while (tree.index != -1 && tree.interval.left < right) {\n seg_left = TSK_MAX((tsk_size_t) tree.interval.left, (tsk_size_t) left);\n seg_right = TSK_MIN((tsk_size_t) tree.interval.right, (tsk_size_t) right);\n if (seg_right > seg_left) {\n for (i = 0; i < num_nodes; i++) {\n u = nodes[i];\n if (tree.parent[u] == TSK_NULL && tree.left_child[u] == TSK_NULL) {\n row = alignments_out + i * L;\n /* memset takes an `int`, `missing_data_character` is a `char` which\n * can be signed or unsigned depending on the platform, so we need to\n * cast. Some tools/compilers will warn if we just cast\n * to `unsigned char` and leave the cast to `int` as implicit, hence\n * the double cast. */\n tsk_memset(row + (seg_left - (tsk_size_t) left),\n (int) (unsigned char) missing_data_character,\n seg_right - seg_left);\n }\n }\n }\n ret = tsk_tree_next(&tree);\n if (ret < 0) {\n goto out;\n }\n }\n\n /* On success we should return 0, not TSK_TREE_OK from the last tsk_tree_next */\n ret = 0;\nout:\n tsk_tree_free(&tree);\n return ret;\n}\n\nstatic int\ntsk_treeseq_decode_alignments_overlay_sites(const tsk_treeseq_t *self,\n const tsk_id_t *nodes, tsk_size_t num_nodes, double left, double right,\n char missing_data_character, tsk_size_t L, char *alignments_out, tsk_flags_t options)\n{\n int ret = 0;\n tsk_variant_t var;\n tsk_id_t site_id;\n tsk_site_t site;\n char *allele_byte = NULL;\n tsk_size_t allele_cap = 0;\n tsk_size_t i, j;\n char *row = NULL;\n int32_t g;\n char c;\n char *tmp = NULL;\n\n tsk_memset(&var, 0, sizeof(var));\n\n ret = tsk_variant_init(&var, self, nodes, num_nodes, NULL, options);\n if (ret != 0) {\n goto out;\n }\n for (site_id = 0; site_id < (tsk_id_t) tsk_treeseq_get_num_sites(self); site_id++) {\n ret = tsk_treeseq_get_site(self, site_id, &site);\n if (ret != 0) {\n goto out;\n }\n if (site.position < left) {\n continue;\n }\n if (site.position >= right) {\n break;\n }\n ret = tsk_variant_decode(&var, site_id, 0);\n if (ret != 0) {\n goto out;\n }\n if (var.num_alleles > 0) {\n if (var.num_alleles > allele_cap) {\n tmp = tsk_realloc(allele_byte, var.num_alleles * sizeof(*allele_byte));\n if (tmp == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n allele_byte = tmp;\n allele_cap = var.num_alleles;\n }\n for (j = 0; j < var.num_alleles; j++) {\n if (var.allele_lengths[j] != 1) {\n ret = tsk_trace_error(TSK_ERR_BAD_ALLELE_LENGTH);\n goto out;\n }\n allele_byte[j] = var.alleles[j][0];\n if (allele_byte[j] == missing_data_character) {\n ret = tsk_trace_error(TSK_ERR_MISSING_CHAR_COLLISION);\n goto out;\n }\n }\n for (i = 0; i < num_nodes; i++) {\n row = alignments_out + i * L;\n g = var.genotypes[i];\n c = missing_data_character;\n if (g != TSK_MISSING_DATA) {\n tsk_bug_assert(g >= 0);\n tsk_bug_assert((tsk_size_t) g < var.num_alleles);\n c = allele_byte[g];\n }\n row[((tsk_size_t) site.position) - (tsk_size_t) left] = (char) c;\n }\n }\n }\n\nout:\n tsk_safe_free(allele_byte);\n tsk_variant_free(&var);\n return ret;\n}\n\n/* NOTE: We usually keep functions with a tsk_treeseq_t signature in trees.c.\n * tsk_treeseq_decode_alignments is implemented here instead because it\n * depends directly on tsk_variant_t and the genotype/allele machinery in\n * this file (and thus on genotypes.h). This slightly breaks that layering\n * convention but keeps the implementation close to the variant code. */\nint\ntsk_treeseq_decode_alignments(const tsk_treeseq_t *self, const char *ref_seq,\n tsk_size_t ref_seq_length, const tsk_id_t *nodes, tsk_size_t num_nodes, double left,\n double right, char missing_data_character, char *alignments_out, tsk_flags_t options)\n{\n int ret = 0;\n tsk_size_t i, L;\n char *row = NULL;\n\n if (!tsk_treeseq_get_discrete_genome(self)) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if (ref_seq == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if (ref_seq_length != (tsk_size_t) tsk_treeseq_get_sequence_length(self)) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if (trunc(left) != left || trunc(right) != right) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if (left < 0 || right > tsk_treeseq_get_sequence_length(self)\n || (tsk_size_t) left >= (tsk_size_t) right) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n L = (tsk_size_t) right - (tsk_size_t) left;\n if (num_nodes == 0) {\n return 0;\n }\n if (nodes == NULL || alignments_out == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n for (i = 0; i < num_nodes; i++) {\n if (nodes[i] < 0 || nodes[i] >= (tsk_id_t) tsk_treeseq_get_num_nodes(self)) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n }\n\n /* Fill rows with the reference slice */\n for (i = 0; i < num_nodes; i++) {\n row = alignments_out + i * L;\n tsk_memcpy(row, ref_seq + (tsk_size_t) left, L);\n }\n if (!(options & TSK_ISOLATED_NOT_MISSING)) {\n ret = tsk_treeseq_decode_alignments_overlay_missing(self, nodes, num_nodes, left,\n right, missing_data_character, L, alignments_out);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_treeseq_decode_alignments_overlay_sites(self, nodes, num_nodes, left,\n right, missing_data_character, L, alignments_out, options);\n if (ret != 0) {\n goto out;\n }\n\nout:\n return ret;\n}\n"
},
{
"path": "c/tskit/genotypes.h",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2022 Tskit Developers\n * Copyright (c) 2016-2018 University of Oxford\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#ifndef TSK_GENOTYPES_H\n#define TSK_GENOTYPES_H\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#include \n\n#define TSK_ISOLATED_NOT_MISSING (1 << 1)\n\n/**\n@brief A variant at a specific site.\n\n@rst\nUsed to generate the genotypes for a given set of samples at a given\nsite.\n@endrst\n*/\ntypedef struct {\n /** @brief Unowned reference to the tree sequence of the variant */\n const tsk_treeseq_t *tree_sequence;\n /** @brief The site this variant is currently decoded at*/\n tsk_site_t site;\n tsk_tree_t tree;\n /** @brief Array of allele strings that the genotypes of the variant refer to\n * These are not NULL terminated - use `allele_lengths` for example:.\n * `printf(\"%.*s\", (int) var->allele_lengths[j], var->alleles[j]);`\n */\n const char **alleles;\n /** @brief Lengths of the allele strings */\n tsk_size_t *allele_lengths;\n /** @brief Length of the allele array */\n tsk_size_t num_alleles;\n tsk_size_t max_alleles;\n /** @brief If True the genotypes of isolated nodes have been decoded to the \"missing\"\n * genotype. If False they are set to the ancestral state (in the absence of\n * mutations above them)*/\n bool has_missing_data;\n /** @brief Array of genotypes for the current site */\n int32_t *genotypes;\n /** @brief Number of samples */\n tsk_size_t num_samples;\n /** @brief Array of sample ids used*/\n tsk_id_t *samples;\n\n const tsk_id_t *sample_index_map;\n bool user_alleles;\n char *user_alleles_mem;\n tsk_id_t *traversal_stack;\n tsk_flags_t options;\n tsk_id_t *alt_samples;\n tsk_id_t *alt_sample_index_map;\n\n} tsk_variant_t;\n\n/* All vargen related structs and methods were deprecated in C API v1.0 */\ntypedef struct {\n const tsk_treeseq_t *tree_sequence;\n tsk_id_t site_index;\n tsk_variant_t variant;\n} tsk_vargen_t;\n\n/**\n@defgroup VARIANT_API_GROUP Variant API for obtaining genotypes.\n@{\n*/\n\n/**\n@brief Initialises the variant by allocating the internal memory\n\n@rst\nThis must be called before any operations are performed on the variant.\nSee the :ref:`sec_c_api_overview_structure` for details on how objects\nare initialised and freed.\n@endrst\n\n@param self A pointer to an uninitialised tsk_variant_t object.\n@param tree_sequence A pointer to the tree sequence from which this variant\nwill decode genotypes. No copy is taken, so this tree sequence must persist\nfor the lifetime of the variant.\n@param samples Optional. Either `NULL` or an array of node ids of the samples that are to\nhave their genotypes decoded. A copy of this array will be taken by the variant. If\n`NULL` then the samples from the tree sequence will be used.\n@param num_samples The number of ids in the samples array, ignored if `samples` is `NULL`\n@param alleles Optional. Either ``NULL`` or an array of string alleles with a terminal\n``NULL`` sentinel value.\nIf specified, the genotypes will be decoded to match the index in this allele array.\nIf ``NULL`` then alleles will be automatically determined from the mutations encountered.\n@param options Variant options. Either ``0`` or ``TSK_ISOLATED_NOT_MISSING`` which\nif specified indicates that isolated sample nodes should not be decoded as the \"missing\"\nstate but as the ancestral state (or the state of any mutation above them).\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_variant_init(tsk_variant_t *self, const tsk_treeseq_t *tree_sequence,\n const tsk_id_t *samples, tsk_size_t num_samples, const char **alleles,\n tsk_flags_t options);\n\n/**\n@brief Copies the state of this variant to another variant\n\n@rst\nCopies the site, genotypes and alleles from this variant to another. Note that\nthe other variant should be uninitialised as this method does not free any\nmemory that the other variant owns. After copying `other` is frozen and\nthis restricts it from being further decoded at any site. `self` remains unchanged.\n@endrst\n\n@param self A pointer to an initialised and decoded tsk_variant_t object.\n@param other A pointer to an uninitialised tsk_variant_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_variant_restricted_copy(const tsk_variant_t *self, tsk_variant_t *other);\n\n/**\n@brief Decode the genotypes at the given site, storing them in this variant.\n\n@rst\nDecodes the genotypes for this variant's samples, indexed to this variant's alleles,\nat the specified site.\nThis method is most efficient at decoding sites in-order, either forwards or backwards\nalong the tree sequence. Resulting genotypes are stored in the ``genotypes`` member of\nthis variant.\n@endrst\n\n@param self A pointer to an initialised tsk_variant_t object.\n@param site_id A valid site id for the tree sequence of this variant.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of `tskit`.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_variant_decode(tsk_variant_t *self, tsk_id_t site_id, tsk_flags_t options);\n\n/**\n@brief Free the internal memory for the specified variant.\n\n@param self A pointer to an initialised tsk_variant_t object.\n@return Always returns 0.\n*/\nint tsk_variant_free(tsk_variant_t *self);\n\n/**\n@brief Print out the state of this variant to the specified stream.\n\nThis method is intended for debugging purposes and should not be used\nin production code. The format of the output should **not** be depended\non and may change arbitrarily between versions.\n\n@param self A pointer to a tsk_variant_t object.\n@param out The stream to write the summary to.\n*/\nvoid tsk_variant_print_state(const tsk_variant_t *self, FILE *out);\n\n/** @} */\n\n/* Deprecated vargen methods (since C API v1.0) */\nint tsk_vargen_init(tsk_vargen_t *self, const tsk_treeseq_t *tree_sequence,\n const tsk_id_t *samples, tsk_size_t num_samples, const char **alleles,\n tsk_flags_t options);\nint tsk_vargen_next(tsk_vargen_t *self, tsk_variant_t **variant);\nint tsk_vargen_free(tsk_vargen_t *self);\nvoid tsk_vargen_print_state(const tsk_vargen_t *self, FILE *out);\n\n#ifdef __cplusplus\n}\n#endif\n#endif\n"
},
{
"path": "c/tskit/haplotype_matching.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2025 Tskit Developers\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#define MAX_PARSIMONY_WORDS 256\n\nconst char *_zero_one_alleles[] = { \"0\", \"1\", NULL };\nconst char *_acgt_alleles[] = { \"A\", \"C\", \"G\", \"T\", NULL };\n\nstatic int\ncmp_double(const void *a, const void *b)\n{\n const double *ia = (const double *) a;\n const double *ib = (const double *) b;\n return (*ia > *ib) - (*ia < *ib);\n}\n\nstatic int\ncmp_argsort(const void *a, const void *b)\n{\n const tsk_argsort_t *ia = (const tsk_argsort_t *) a;\n const tsk_argsort_t *ib = (const tsk_argsort_t *) b;\n int ret = (ia->value > ib->value) - (ia->value < ib->value);\n /* Break any ties using the index to ensure consistency */\n if (ret == 0) {\n ret = (ia->index > ib->index) - (ia->index < ib->index);\n }\n return ret;\n}\n\nstatic void\ntsk_ls_hmm_check_state(tsk_ls_hmm_t *self)\n{\n tsk_id_t *T_index = self->transition_index;\n tsk_value_transition_t *T = self->transitions;\n tsk_id_t j;\n\n for (j = 0; j < (tsk_id_t) self->num_transitions; j++) {\n if (T[j].tree_node != TSK_NULL) {\n tsk_bug_assert(T_index[T[j].tree_node] == j);\n }\n }\n /* tsk_bug_assert(self->num_transitions <= self->num_samples); */\n\n if (self->num_transitions > 0) {\n for (j = 0; j < (tsk_id_t) self->num_nodes; j++) {\n if (T_index[j] != TSK_NULL) {\n tsk_bug_assert(T[T_index[j]].tree_node == j);\n }\n tsk_bug_assert(self->tree.parent[j] == self->parent[j]);\n }\n }\n}\n\nvoid\ntsk_ls_hmm_print_state(tsk_ls_hmm_t *self, FILE *out)\n{\n tsk_size_t j, l;\n\n fprintf(out, \"tree_sequence = %p\\n\", (void *) self->tree_sequence);\n fprintf(out, \"num_sites = %lld\\n\", (long long) self->num_sites);\n fprintf(out, \"num_samples = %lld\\n\", (long long) self->num_samples);\n fprintf(out, \"num_values = %lld\\n\", (long long) self->num_values);\n fprintf(out, \"max_values = %lld\\n\", (long long) self->max_values);\n fprintf(out, \"num_optimal_value_set_words = %lld\\n\",\n (long long) self->num_optimal_value_set_words);\n\n fprintf(out, \"sites::\\n\");\n for (l = 0; l < self->num_sites; l++) {\n fprintf(out, \"%lld\\t%lld\\t[\", (long long) l, (long long) self->num_alleles[l]);\n for (j = 0; j < self->num_alleles[l]; j++) {\n fprintf(out, \"%s,\", self->alleles[l][j]);\n }\n fprintf(out, \"]\\n\");\n }\n fprintf(out, \"transitions::%lld\\n\", (long long) self->num_transitions);\n for (j = 0; j < self->num_transitions; j++) {\n fprintf(out, \"tree_node=%lld\\tvalue=%.14f\\tvalue_index=%lld\\n\",\n (long long) self->transitions[j].tree_node, self->transitions[j].value,\n (long long) self->transitions[j].value_index);\n }\n if (self->num_transitions > 0) {\n fprintf(out, \"tree::%lld\\n\", (long long) self->num_nodes);\n for (j = 0; j < self->num_nodes; j++) {\n fprintf(out, \"%lld\\tparent=%lld\\ttransition=%lld\\n\", (long long) j,\n (long long) self->parent[j], (long long) self->transition_index[j]);\n }\n }\n tsk_ls_hmm_check_state(self);\n}\n\nint TSK_WARN_UNUSED\ntsk_ls_hmm_init(tsk_ls_hmm_t *self, tsk_treeseq_t *tree_sequence,\n double *recombination_rate, double *mutation_rate, tsk_flags_t options)\n{\n int ret = TSK_ERR_GENERIC;\n tsk_size_t l;\n\n tsk_memset(self, 0, sizeof(tsk_ls_hmm_t));\n self->tree_sequence = tree_sequence;\n self->precision = 6; /* Seems like a safe value, but probably not ideal for perf */\n self->num_sites = tsk_treeseq_get_num_sites(tree_sequence);\n self->num_samples = tsk_treeseq_get_num_samples(tree_sequence);\n self->num_alleles = tsk_malloc(self->num_sites * sizeof(*self->num_alleles));\n self->num_nodes = tsk_treeseq_get_num_nodes(tree_sequence);\n self->parent = tsk_malloc(self->num_nodes * sizeof(*self->parent));\n self->allelic_state = tsk_malloc(self->num_nodes * sizeof(*self->allelic_state));\n self->transition_index\n = tsk_malloc(self->num_nodes * sizeof(*self->transition_index));\n self->transition_stack\n = tsk_malloc(self->num_nodes * sizeof(*self->transition_stack));\n /* We can't have more than 2 * num_samples transitions, so we use this as the\n * upper bound. Because of the implementation, we'll also have to worry about\n * the extra mutations at the first site, which in worst case involves all\n * mutations. We can definitely save some memory here if we want to.*/\n self->max_transitions\n = 2 * self->num_samples + tsk_treeseq_get_num_mutations(tree_sequence);\n /* FIXME Arbitrarily doubling this after hitting problems */\n self->max_transitions *= 2;\n self->transitions = tsk_malloc(self->max_transitions * sizeof(*self->transitions));\n self->transitions_copy\n = tsk_malloc(self->max_transitions * sizeof(*self->transitions));\n self->num_transition_samples\n = tsk_malloc(self->max_transitions * sizeof(*self->num_transition_samples));\n self->transition_parent\n = tsk_malloc(self->max_transitions * sizeof(*self->transition_parent));\n self->transition_time_order\n = tsk_malloc(self->max_transitions * sizeof(*self->transition_time_order));\n self->values = tsk_malloc(self->max_transitions * sizeof(*self->values));\n self->recombination_rate\n = tsk_malloc(self->num_sites * sizeof(*self->recombination_rate));\n self->mutation_rate = tsk_malloc(self->num_sites * sizeof(*self->mutation_rate));\n self->alleles = tsk_calloc(self->num_sites, sizeof(*self->alleles));\n if (self->num_alleles == NULL || self->parent == NULL || self->allelic_state == NULL\n || self->transition_index == NULL || self->transition_stack == NULL\n || self->transitions == NULL || self->transitions_copy == NULL\n || self->num_transition_samples == NULL || self->transition_parent == NULL\n || self->transition_time_order == NULL || self->values == NULL\n || self->recombination_rate == NULL || self->mutation_rate == NULL\n || self->alleles == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n for (l = 0; l < self->num_sites; l++) {\n /* TODO check these inputs */\n self->recombination_rate[l] = recombination_rate[l];\n self->mutation_rate[l] = mutation_rate[l];\n if (options & TSK_ALLELES_ACGT) {\n self->num_alleles[l] = 4;\n self->alleles[l] = _acgt_alleles;\n } else {\n /* Default to the 0/1 alleles */\n self->num_alleles[l] = 2;\n self->alleles[l] = _zero_one_alleles;\n }\n }\n ret = tsk_tree_init(&self->tree, self->tree_sequence, 0);\n if (ret != 0) {\n goto out;\n }\n self->num_values = 0;\n self->max_values = 0;\n /* Keep this as a struct variable so that we can test overflow, but this\n * should never be set to more than MAX_PARSIMONY_WORDS as we're doing\n * a bunch of stack allocations based on this. */\n self->max_parsimony_words = MAX_PARSIMONY_WORDS;\n ret = 0;\nout:\n return ret;\n}\n\nint\ntsk_ls_hmm_set_precision(tsk_ls_hmm_t *self, unsigned int precision)\n{\n self->precision = precision;\n return 0;\n}\n\nint\ntsk_ls_hmm_free(tsk_ls_hmm_t *self)\n{\n tsk_tree_free(&self->tree);\n tsk_safe_free(self->recombination_rate);\n tsk_safe_free(self->mutation_rate);\n tsk_safe_free(self->recombination_rate);\n tsk_safe_free(self->alleles);\n tsk_safe_free(self->num_alleles);\n tsk_safe_free(self->parent);\n tsk_safe_free(self->allelic_state);\n tsk_safe_free(self->transition_index);\n tsk_safe_free(self->transition_stack);\n tsk_safe_free(self->transitions);\n tsk_safe_free(self->transitions_copy);\n tsk_safe_free(self->transition_time_order);\n tsk_safe_free(self->values);\n tsk_safe_free(self->num_transition_samples);\n tsk_safe_free(self->transition_parent);\n tsk_safe_free(self->optimal_value_sets);\n return 0;\n}\n\nstatic int\ntsk_ls_hmm_reset(tsk_ls_hmm_t *self, double value)\n{\n int ret = 0;\n tsk_size_t j;\n tsk_id_t u;\n const tsk_id_t *samples;\n tsk_size_t N = self->num_nodes;\n\n tsk_memset(self->parent, 0xff, N * sizeof(*self->parent));\n tsk_memset(self->transition_index, 0xff, N * sizeof(*self->transition_index));\n tsk_memset(self->allelic_state, 0xff, N * sizeof(*self->allelic_state));\n tsk_memset(self->transitions, 0, self->max_transitions * sizeof(*self->transitions));\n tsk_memset(self->num_transition_samples, 0,\n self->max_transitions * sizeof(*self->num_transition_samples));\n tsk_memset(self->transition_parent, 0xff,\n self->max_transitions * sizeof(*self->transition_parent));\n\n samples = tsk_treeseq_get_samples(self->tree_sequence);\n for (j = 0; j < self->num_samples; j++) {\n u = samples[j];\n self->transitions[j].tree_node = u;\n self->transitions[j].value = value;\n self->transition_index[u] = (tsk_id_t) j;\n }\n self->num_transitions = self->num_samples;\n return ret;\n}\n\n/* After we have moved on to a new tree we can have transitions still associated\n * with the old roots, which are now disconnected. Remove. */\nstatic int\ntsk_ls_hmm_remove_dead_roots(tsk_ls_hmm_t *self)\n{\n tsk_id_t *restrict T_index = self->transition_index;\n tsk_value_transition_t *restrict T = self->transitions;\n const tsk_id_t *restrict right_sib = self->tree.right_sib;\n const tsk_id_t left_root = tsk_tree_get_left_root(&self->tree);\n const tsk_id_t *restrict parent = self->parent;\n tsk_id_t root, u;\n tsk_size_t j;\n const tsk_id_t root_marker = -2;\n\n for (root = left_root; root != TSK_NULL; root = right_sib[root]) {\n if (T_index[root] != TSK_NULL) {\n /* Use the value_index slot as a marker. We don't use this between\n * iterations, so it's safe to appropriate here */\n T[T_index[root]].value_index = root_marker;\n }\n }\n for (j = 0; j < self->num_transitions; j++) {\n u = T[j].tree_node;\n if (u != TSK_NULL) {\n if (parent[u] == TSK_NULL && T[j].value_index != root_marker) {\n T_index[u] = TSK_NULL;\n T[j].tree_node = TSK_NULL;\n }\n T[j].value_index = -1;\n }\n }\n return 0;\n}\n\nstatic int\ntsk_ls_hmm_update_tree(tsk_ls_hmm_t *self, int direction)\n{\n int ret = 0;\n tsk_id_t *restrict parent = self->parent;\n tsk_id_t *restrict T_index = self->transition_index;\n const tsk_id_t *restrict edges_child = self->tree_sequence->tables->edges.child;\n const tsk_id_t *restrict edges_parent = self->tree_sequence->tables->edges.parent;\n tsk_value_transition_t *restrict T = self->transitions;\n tsk_id_t u, c, p, j, e;\n tsk_value_transition_t *vt;\n tsk_tree_position_t tree_pos;\n\n tree_pos = self->tree.tree_pos;\n for (j = tree_pos.out.start; j != tree_pos.out.stop; j += direction) {\n e = tree_pos.out.order[j];\n c = edges_child[e];\n u = c;\n if (T_index[u] == TSK_NULL) {\n /* Ensure the subtree we're detaching has a transition at the root */\n while (T_index[u] == TSK_NULL) {\n u = parent[u];\n tsk_bug_assert(u != TSK_NULL);\n }\n tsk_bug_assert(self->num_transitions < self->max_transitions);\n T_index[c] = (tsk_id_t) self->num_transitions;\n T[self->num_transitions].tree_node = c;\n T[self->num_transitions].value = T[T_index[u]].value;\n self->num_transitions++;\n }\n parent[c] = TSK_NULL;\n }\n\n for (j = tree_pos.in.start; j != tree_pos.in.stop; j += direction) {\n e = tree_pos.in.order[j];\n c = edges_child[e];\n p = edges_parent[e];\n parent[c] = p;\n u = p;\n if (parent[p] == TSK_NULL) {\n /* Grafting onto a new root. */\n if (T_index[p] == TSK_NULL) {\n T_index[p] = (tsk_id_t) self->num_transitions;\n tsk_bug_assert(self->num_transitions < self->max_transitions);\n T[self->num_transitions].tree_node = p;\n T[self->num_transitions].value = T[T_index[c]].value;\n self->num_transitions++;\n }\n } else {\n /* Grafting into an existing subtree. */\n while (T_index[u] == TSK_NULL) {\n u = parent[u];\n }\n tsk_bug_assert(u != TSK_NULL);\n }\n tsk_bug_assert(T_index[u] != -1 && T_index[c] != -1);\n if (T[T_index[u]].value == T[T_index[c]].value) {\n vt = &T[T_index[c]];\n /* Mark the value transition as unusued */\n vt->value = -1;\n vt->tree_node = TSK_NULL;\n T_index[c] = TSK_NULL;\n }\n }\n\n ret = tsk_ls_hmm_remove_dead_roots(self);\n return ret;\n}\n\nstatic int\ntsk_ls_hmm_get_allele_index(tsk_ls_hmm_t *self, tsk_id_t site, const char *allele_state,\n const tsk_size_t allele_length)\n{\n /* Note we're not doing tsk_trace_error here because it would require changing\n * the logic of the function. Could be done easily enough, though */\n int ret = TSK_ERR_ALLELE_NOT_FOUND;\n const char **alleles = self->alleles[site];\n const tsk_id_t num_alleles = (tsk_id_t) self->num_alleles[site];\n\n tsk_id_t j;\n\n for (j = 0; j < num_alleles; j++) {\n if (strlen(alleles[j]) != allele_length) {\n break;\n }\n if (strncmp(alleles[j], allele_state, (size_t) allele_length) == 0) {\n ret = (int) j;\n break;\n }\n }\n return ret;\n}\n\nstatic int\ntsk_ls_hmm_update_probabilities(\n tsk_ls_hmm_t *self, const tsk_site_t *site, int32_t haplotype_state)\n{\n int ret = 0;\n tsk_id_t root;\n tsk_tree_t *tree = &self->tree;\n tsk_id_t *restrict parent = self->parent;\n tsk_id_t *restrict T_index = self->transition_index;\n tsk_value_transition_t *restrict T = self->transitions;\n int32_t *restrict allelic_state = self->allelic_state;\n const tsk_id_t left_root = tsk_tree_get_left_root(tree);\n tsk_mutation_t mut;\n tsk_id_t j, u, v;\n double x;\n bool match;\n\n /* Set the allelic states */\n ret = tsk_ls_hmm_get_allele_index(\n self, site->id, site->ancestral_state, site->ancestral_state_length);\n if (ret < 0) {\n goto out;\n }\n for (root = left_root; root != TSK_NULL; root = tree->right_sib[root]) {\n allelic_state[root] = (int32_t) ret;\n }\n\n for (j = 0; j < (tsk_id_t) site->mutations_length; j++) {\n mut = site->mutations[j];\n ret = tsk_ls_hmm_get_allele_index(\n self, site->id, mut.derived_state, mut.derived_state_length);\n if (ret < 0) {\n goto out;\n }\n u = mut.node;\n allelic_state[u] = (int32_t) ret;\n if (T_index[u] == TSK_NULL) {\n while (T_index[u] == TSK_NULL) {\n u = parent[u];\n }\n tsk_bug_assert(self->num_transitions < self->max_transitions);\n T_index[mut.node] = (tsk_id_t) self->num_transitions;\n T[self->num_transitions].tree_node = mut.node;\n T[self->num_transitions].value = T[T_index[u]].value;\n self->num_transitions++;\n }\n }\n\n for (j = 0; j < (tsk_id_t) self->num_transitions; j++) {\n u = T[j].tree_node;\n if (u != TSK_NULL) {\n /* Get the allelic_state at u. */\n v = u;\n while (allelic_state[v] == TSK_MISSING_DATA) {\n v = parent[v];\n tsk_bug_assert(v != -1);\n }\n match = haplotype_state == TSK_MISSING_DATA\n || haplotype_state == allelic_state[v];\n ret = self->next_probability(self, site->id, T[j].value, match, u, &x);\n if (ret != 0) {\n goto out;\n }\n T[j].value = x;\n }\n }\n\n /* Unset the allelic states */\n for (root = left_root; root != TSK_NULL; root = tree->right_sib[root]) {\n allelic_state[root] = TSK_MISSING_DATA;\n }\n for (j = 0; j < (tsk_id_t) site->mutations_length; j++) {\n mut = site->mutations[j];\n allelic_state[mut.node] = TSK_MISSING_DATA;\n }\n ret = 0;\nout:\n return ret;\n}\n\nstatic int\ntsk_ls_hmm_discretise_values(tsk_ls_hmm_t *self)\n{\n int ret = 0;\n tsk_value_transition_t *T = self->transitions;\n double *values = self->values;\n tsk_size_t j, k, num_values;\n\n num_values = 0;\n for (j = 0; j < self->num_transitions; j++) {\n if (T[j].tree_node != TSK_NULL) {\n values[num_values] = T[j].value;\n num_values++;\n }\n }\n tsk_bug_assert(num_values > 0);\n\n qsort(values, (size_t) num_values, sizeof(double), cmp_double);\n\n k = 0;\n for (j = 1; j < num_values; j++) {\n if (values[j] != values[k]) {\n k++;\n values[k] = values[j];\n }\n }\n num_values = k + 1;\n self->num_values = num_values;\n for (j = 0; j < self->num_transitions; j++) {\n if (T[j].tree_node != TSK_NULL) {\n T[j].value_index\n = (tsk_id_t) tsk_search_sorted(values, num_values, T[j].value);\n tsk_bug_assert(T[j].value == self->values[T[j].value_index]);\n }\n }\n return ret;\n}\n\n/*\n * TODO We also have these function in tree.c where they're used in the\n * parsimony calculations (which are slightly different). It would be good to bring\n * these together, or at least avoid having the same function in two\n * files. Keeping it as it is for now so that it can be inlined, since\n * it's perf-sensitive. */\n\nstatic inline tsk_id_t\nget_smallest_set_bit(uint64_t v)\n{\n /* This is an inefficient implementation, there are several better\n * approaches. On GCC we can use\n * return (uint8_t) (__builtin_ffsll((long long) v) - 1);\n */\n uint64_t t = 1;\n tsk_id_t r = 0;\n assert(v != 0);\n\n while ((v & t) == 0) {\n t <<= 1;\n r++;\n }\n return r;\n}\n\nstatic inline uint64_t\nset_bit(uint64_t value, uint8_t bit)\n{\n return value | (1ULL << bit);\n}\n\nstatic inline bool\nbit_is_set(uint64_t value, uint8_t bit)\n{\n return (value & (1ULL << bit)) != 0;\n}\n\nstatic inline tsk_id_t\nget_smallest_element(const uint64_t *restrict A, tsk_size_t u, tsk_size_t num_words)\n{\n tsk_size_t base = u * num_words;\n const uint64_t *restrict a = A + base;\n tsk_id_t j = 0;\n\n while (a[j] == 0) {\n j++;\n tsk_bug_assert(j < (tsk_id_t) num_words);\n }\n return j * 64 + get_smallest_set_bit(a[j]);\n}\n\n/* static variables are zero-initialised by default. */\nstatic const uint64_t zero_block[MAX_PARSIMONY_WORDS];\n\nstatic inline bool\nall_zero(const uint64_t *restrict A, tsk_id_t u, tsk_size_t num_words)\n{\n if (num_words == 1) {\n return A[u] == 0;\n } else {\n return tsk_memcmp(\n zero_block, A + (tsk_size_t) u * num_words, num_words * sizeof(*A))\n == 0;\n }\n}\n\nstatic inline bool\nelement_in(\n const uint64_t *restrict A, tsk_id_t u, const tsk_id_t state, tsk_size_t num_words)\n{\n tsk_size_t index = ((tsk_size_t) u) * num_words + (tsk_size_t) (state / 64);\n return (A[index] & (1ULL << (state % 64))) != 0;\n}\n\nstatic inline void\nset_optimal_value(\n uint64_t *restrict A, tsk_id_t u, const tsk_size_t num_words, tsk_id_t state)\n{\n tsk_size_t index = ((tsk_size_t) u) * num_words + (tsk_size_t) (state / 64);\n tsk_bug_assert(((tsk_size_t) state) / 64 < num_words);\n A[index] |= 1ULL << (state % 64);\n}\n\n/* TODO the implementation here isn't particularly optimal and the way things\n * were organised was really driven by the old Fitch parsimony algorithm\n * (which only worked on binary trees. In particular, we should be working\n * word-by-word where possible rather than iterating by values like we do here.\n * Needs to be reworked when we're documenting/writing up this algorithm.\n */\n\nstatic void\ncompute_optimal_value_1(uint64_t *restrict A, const tsk_id_t *restrict left_child,\n const tsk_id_t *restrict right_sib, const tsk_id_t u, const tsk_id_t parent_state,\n const tsk_size_t num_values)\n{\n tsk_id_t v;\n uint64_t child;\n tsk_size_t value_count[64], max_value_count;\n uint8_t j;\n\n assert(num_values < 64);\n\n tsk_memset(value_count, 0, num_values * sizeof(*value_count));\n for (v = left_child[u]; v != TSK_NULL; v = right_sib[v]) {\n child = A[v];\n /* If the set for a given child is empty, then we know it inherits\n * directly from the parent state and must be a singleton set. */\n if (child == 0) {\n child = 1ULL << parent_state;\n }\n for (j = 0; j < num_values; j++) {\n value_count[j] += bit_is_set(child, j);\n }\n }\n max_value_count = 0;\n for (j = 0; j < num_values; j++) {\n max_value_count = TSK_MAX(max_value_count, value_count[j]);\n }\n A[u] = 0;\n for (j = 0; j < num_values; j++) {\n if (value_count[j] == max_value_count) {\n A[u] = set_bit(A[u], j);\n }\n }\n}\n\nstatic void\ncompute_optimal_value_general(uint64_t *restrict A, const tsk_id_t *restrict left_child,\n const tsk_id_t *restrict right_sib, const tsk_id_t u, const tsk_id_t parent_state,\n const tsk_size_t num_values, const tsk_size_t num_words)\n{\n tsk_id_t v;\n uint64_t child[MAX_PARSIMONY_WORDS];\n uint64_t *Au;\n tsk_size_t base, word, bit;\n bool child_all_zero;\n const tsk_id_t state_index = parent_state / 64;\n const uint64_t state_word = 1ULL << (parent_state % 64);\n tsk_size_t value_count[64 * MAX_PARSIMONY_WORDS], max_value_count;\n tsk_size_t j;\n\n tsk_bug_assert(num_values < 64 * MAX_PARSIMONY_WORDS);\n tsk_bug_assert(num_words <= MAX_PARSIMONY_WORDS);\n for (j = 0; j < num_values; j++) {\n value_count[j] = 0;\n }\n\n for (v = left_child[u]; v != TSK_NULL; v = right_sib[v]) {\n child_all_zero = true;\n base = ((tsk_size_t) v) * num_words;\n for (word = 0; word < num_words; word++) {\n child[word] = A[base + word];\n child_all_zero = child_all_zero && (child[word] == 0);\n }\n /* If the set for a given child is empty, then we know it inherits\n * directly from the parent state and must be a singleton set. */\n if (child_all_zero) {\n child[state_index] = state_word;\n }\n for (j = 0; j < num_values; j++) {\n word = j / 64;\n bit = j % 64;\n assert(word < num_words);\n value_count[j] += bit_is_set(child[word], (uint8_t) bit);\n }\n }\n max_value_count = 0;\n for (j = 0; j < num_values; j++) {\n max_value_count = TSK_MAX(max_value_count, value_count[j]);\n }\n\n Au = A + ((size_t) u * num_words);\n for (word = 0; word < num_words; word++) {\n Au[word] = 0;\n }\n for (j = 0; j < num_values; j++) {\n if (value_count[j] == max_value_count) {\n word = j / 64;\n bit = j % 64;\n Au[word] = set_bit(Au[word], (uint8_t) bit);\n }\n }\n}\n\nstatic void\ncompute_optimal_value(uint64_t *restrict A, const tsk_id_t *restrict left_child,\n const tsk_id_t *restrict right_sib, const tsk_id_t u, const tsk_id_t parent_state,\n const tsk_size_t num_values, const tsk_size_t num_words)\n{\n if (num_words == 1) {\n compute_optimal_value_1(A, left_child, right_sib, u, parent_state, num_values);\n } else {\n compute_optimal_value_general(\n A, left_child, right_sib, u, parent_state, num_values, num_words);\n }\n}\n\nstatic int\ntsk_ls_hmm_setup_optimal_value_sets(tsk_ls_hmm_t *self)\n{\n int ret = 0;\n\n /* We expect that most of the time there will be one word per optimal_value set,\n * but there will be times when we need more than one word. This approach\n * lets us expand the memory if we need to, but when the number of\n * values goes back below 64 we revert to using one word per set. We\n * could in principle release back the memory as well, but it doesn't seem\n * worth the bother. */\n self->num_optimal_value_set_words = (self->num_values / 64) + 1;\n if (self->num_optimal_value_set_words > self->max_parsimony_words) {\n ret = tsk_trace_error(TSK_ERR_TOO_MANY_VALUES);\n goto out;\n }\n if (self->num_values >= self->max_values) {\n self->max_values = self->num_optimal_value_set_words * 64;\n tsk_safe_free(self->optimal_value_sets);\n self->optimal_value_sets\n = tsk_calloc(self->num_nodes * self->num_optimal_value_set_words,\n sizeof(*self->optimal_value_sets));\n if (self->optimal_value_sets == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_ls_hmm_build_optimal_value_sets(tsk_ls_hmm_t *self)\n{\n int ret = 0;\n const double *restrict node_time = self->tree_sequence->tables->nodes.time;\n const tsk_id_t *restrict left_child = self->tree.left_child;\n const tsk_id_t *restrict right_sib = self->tree.right_sib;\n const tsk_id_t *restrict parent = self->parent;\n const tsk_value_transition_t *restrict T = self->transitions;\n const tsk_id_t *restrict T_index = self->transition_index;\n tsk_argsort_t *restrict order = self->transition_time_order;\n const tsk_size_t num_optimal_value_set_words = self->num_optimal_value_set_words;\n uint64_t *restrict A = self->optimal_value_sets;\n tsk_size_t j;\n tsk_id_t u, v, state, parent_state;\n\n /* argsort the transitions by node time so we can visit them in the\n * correct order */\n for (j = 0; j < self->num_transitions; j++) {\n order[j].index = j;\n order[j].value = DBL_MAX;\n if (T[j].tree_node != TSK_NULL) {\n order[j].value = node_time[T[j].tree_node];\n }\n }\n qsort(order, (size_t) self->num_transitions, sizeof(*order), cmp_argsort);\n\n for (j = 0; j < self->num_transitions; j++) {\n u = T[order[j].index].tree_node;\n if (u != TSK_NULL) {\n state = T[order[j].index].value_index;\n if (left_child[u] == TSK_NULL) {\n /* leaf node */\n set_optimal_value(A, u, num_optimal_value_set_words, state);\n } else {\n compute_optimal_value(A, left_child, right_sib, u, state,\n self->num_values, num_optimal_value_set_words);\n }\n v = parent[u];\n if (v != TSK_NULL) {\n while (T_index[v] == TSK_NULL) {\n v = parent[v];\n tsk_bug_assert(v != TSK_NULL);\n }\n parent_state = T[T_index[v]].value_index;\n v = parent[u];\n while (T_index[v] == TSK_NULL) {\n compute_optimal_value(A, left_child, right_sib, v, parent_state,\n self->num_values, num_optimal_value_set_words);\n v = parent[v];\n tsk_bug_assert(v != TSK_NULL);\n }\n }\n }\n }\n return ret;\n}\n\nstatic int\ntsk_ls_hmm_redistribute_transitions(tsk_ls_hmm_t *self)\n{\n int ret = 0;\n const tsk_id_t *restrict left_child = self->tree.left_child;\n const tsk_id_t *restrict right_sib = self->tree.right_sib;\n const tsk_id_t *restrict parent = self->parent;\n tsk_id_t *restrict T_index = self->transition_index;\n tsk_id_t *restrict T_parent = self->transition_parent;\n tsk_value_transition_t *restrict T = self->transitions;\n tsk_value_transition_t *restrict T_old = self->transitions_copy;\n tsk_transition_stack_t *stack = self->transition_stack;\n uint64_t *restrict A = self->optimal_value_sets;\n const tsk_size_t num_optimal_value_set_words = self->num_optimal_value_set_words;\n tsk_transition_stack_t s, child_s;\n tsk_id_t root, u, v;\n int stack_top = 0;\n tsk_size_t j, old_num_transitions;\n\n tsk_memcpy(T_old, T, self->num_transitions * sizeof(*T));\n old_num_transitions = self->num_transitions;\n self->num_transitions = 0;\n\n /* TODO refactor this to push the virtual root onto the stack rather then\n * iterating over the roots. See the existing parsimony implementations\n * for an example. */\n for (root = tsk_tree_get_left_root(&self->tree); root != TSK_NULL;\n root = right_sib[root]) {\n stack[0].tree_node = root;\n stack[0].old_state = T_old[T_index[root]].value_index;\n stack[0].new_state\n = get_smallest_element(A, (tsk_size_t) root, num_optimal_value_set_words);\n stack[0].transition_parent = 0;\n stack_top = 0;\n\n tsk_bug_assert(self->num_transitions < self->max_transitions);\n T_parent[self->num_transitions] = TSK_NULL;\n T[self->num_transitions].tree_node = stack[0].tree_node;\n T[self->num_transitions].value_index = stack[0].new_state;\n self->num_transitions++;\n\n while (stack_top >= 0) {\n s = stack[stack_top];\n stack_top--;\n for (v = left_child[s.tree_node]; v != TSK_NULL; v = right_sib[v]) {\n child_s = s;\n child_s.tree_node = v;\n if (T_index[v] != TSK_NULL) {\n child_s.old_state = T_old[T_index[v]].value_index;\n }\n if (!all_zero(A, v, num_optimal_value_set_words)) {\n if (!element_in(A, v, s.new_state, num_optimal_value_set_words)) {\n child_s.new_state = get_smallest_element(\n A, (tsk_size_t) v, num_optimal_value_set_words);\n child_s.transition_parent = (tsk_id_t) self->num_transitions;\n /* Add a new transition */\n tsk_bug_assert(self->num_transitions < self->max_transitions);\n T_parent[self->num_transitions] = s.transition_parent;\n T[self->num_transitions].tree_node = v;\n T[self->num_transitions].value_index = child_s.new_state;\n self->num_transitions++;\n }\n stack_top++;\n stack[stack_top] = child_s;\n } else {\n /* Node that we didn't visit when moving up the tree */\n if (s.old_state != s.new_state) {\n tsk_bug_assert(self->num_transitions < self->max_transitions);\n T_parent[self->num_transitions] = s.transition_parent;\n T[self->num_transitions].tree_node = v;\n T[self->num_transitions].value_index = s.old_state;\n self->num_transitions++;\n }\n }\n }\n }\n }\n\n /* Unset the old T_index pointers and optimal_value sets. */\n for (j = 0; j < old_num_transitions; j++) {\n u = T_old[j].tree_node;\n if (u != TSK_NULL) {\n T_index[u] = TSK_NULL;\n while (u != TSK_NULL && !all_zero(A, u, num_optimal_value_set_words)) {\n tsk_memset(A + ((tsk_size_t) u) * num_optimal_value_set_words, 0,\n num_optimal_value_set_words * sizeof(uint64_t));\n u = parent[u];\n }\n }\n }\n /* Set the new pointers for transition nodes and the values.*/\n for (j = 0; j < self->num_transitions; j++) {\n T_index[T[j].tree_node] = (tsk_id_t) j;\n T[j].value = self->values[T[j].value_index];\n }\n return ret;\n}\n\nstatic int\ntsk_ls_hmm_compress(tsk_ls_hmm_t *self)\n{\n int ret = 0;\n\n ret = tsk_ls_hmm_discretise_values(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_ls_hmm_setup_optimal_value_sets(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_ls_hmm_build_optimal_value_sets(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_ls_hmm_redistribute_transitions(self);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_ls_hmm_process_site_forward(\n tsk_ls_hmm_t *self, const tsk_site_t *site, int32_t haplotype_state)\n{\n int ret = 0;\n double x, normalisation_factor;\n tsk_compressed_matrix_t *output = (tsk_compressed_matrix_t *) self->output;\n tsk_value_transition_t *restrict T = self->transitions;\n const unsigned int precision = (unsigned int) self->precision;\n tsk_size_t j;\n\n ret = tsk_ls_hmm_update_probabilities(self, site, haplotype_state);\n if (ret != 0) {\n goto out;\n }\n /* See notes in the Python implementation on why we don't want to compress\n * here, but rather should be doing it after rounding. */\n ret = tsk_ls_hmm_compress(self);\n if (ret != 0) {\n goto out;\n }\n tsk_bug_assert(self->num_transitions <= self->num_samples);\n normalisation_factor = self->compute_normalisation_factor(self);\n\n if (normalisation_factor == 0) {\n ret = tsk_trace_error(TSK_ERR_MATCH_IMPOSSIBLE);\n goto out;\n }\n for (j = 0; j < self->num_transitions; j++) {\n tsk_bug_assert(T[j].tree_node != TSK_NULL);\n x = T[j].value / normalisation_factor;\n T[j].value = tsk_round(x, precision);\n }\n\n ret = tsk_compressed_matrix_store_site(\n output, site->id, normalisation_factor, (tsk_size_t) self->num_transitions, T);\nout:\n return ret;\n}\n\nstatic int\ntsk_ls_hmm_run_forward(tsk_ls_hmm_t *self, int32_t *haplotype)\n{\n int ret = 0;\n int t_ret;\n const tsk_site_t *sites;\n tsk_size_t j, num_sites;\n const double n = (double) self->num_samples;\n\n ret = tsk_ls_hmm_reset(self, 1 / n);\n if (ret != 0) {\n goto out;\n }\n\n for (t_ret = tsk_tree_first(&self->tree); t_ret == TSK_TREE_OK;\n t_ret = tsk_tree_next(&self->tree)) {\n ret = tsk_ls_hmm_update_tree(self, TSK_DIR_FORWARD);\n if (ret != 0) {\n goto out;\n }\n /* tsk_ls_hmm_check_state(self); */\n ret = tsk_tree_get_sites(&self->tree, &sites, &num_sites);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_sites; j++) {\n ret = tsk_ls_hmm_process_site_forward(\n self, &sites[j], haplotype[sites[j].id]);\n if (ret != 0) {\n goto out;\n }\n }\n }\n /* Set to zero so we can print and check the state OK. */\n self->num_transitions = 0;\n if (t_ret != 0) {\n ret = t_ret;\n goto out;\n }\nout:\n return ret;\n}\n\n/****************************************************************\n * Forward Algorithm\n ****************************************************************/\n\nstatic double\ntsk_ls_hmm_compute_normalisation_factor_forward(tsk_ls_hmm_t *self)\n{\n tsk_size_t *restrict N = self->num_transition_samples;\n tsk_value_transition_t *restrict T = self->transitions;\n const tsk_id_t *restrict T_parent = self->transition_parent;\n const tsk_size_t *restrict num_samples = self->tree.num_samples;\n const tsk_id_t num_transitions = (tsk_id_t) self->num_transitions;\n double normalisation_factor;\n tsk_id_t j;\n\n /* Compute the number of samples directly inheriting from each transition */\n for (j = 0; j < num_transitions; j++) {\n tsk_bug_assert(T[j].tree_node != TSK_NULL);\n N[j] = num_samples[T[j].tree_node];\n }\n for (j = 0; j < num_transitions; j++) {\n if (T_parent[j] != TSK_NULL) {\n N[T_parent[j]] -= N[j];\n }\n }\n\n /* Compute the normalising constant used to avoid underflow */\n normalisation_factor = 0;\n for (j = 0; j < num_transitions; j++) {\n normalisation_factor += (double) N[j] * T[j].value;\n }\n return normalisation_factor;\n}\n\nstatic int\ntsk_ls_hmm_next_probability_forward(tsk_ls_hmm_t *self, tsk_id_t site_id, double p_last,\n bool is_match, tsk_id_t TSK_UNUSED(node), double *result)\n{\n const double rho = self->recombination_rate[site_id];\n const double mu = self->mutation_rate[site_id];\n const double n = (double) self->num_samples;\n const double num_alleles = self->num_alleles[site_id];\n double p_t, p_e;\n\n p_t = p_last * (1 - rho) + rho / n;\n p_e = mu;\n if (is_match) {\n p_e = 1 - (num_alleles - 1) * mu;\n }\n *result = p_t * p_e;\n return 0;\n}\n\nint\ntsk_ls_hmm_forward(tsk_ls_hmm_t *self, int32_t *haplotype,\n tsk_compressed_matrix_t *output, tsk_flags_t options)\n{\n int ret = 0;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_compressed_matrix_init(output, self->tree_sequence, 0, 0);\n if (ret != 0) {\n goto out;\n }\n } else {\n if (output->tree_sequence != self->tree_sequence) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n ret = tsk_compressed_matrix_clear(output);\n if (ret != 0) {\n goto out;\n }\n }\n\n self->next_probability = tsk_ls_hmm_next_probability_forward;\n self->compute_normalisation_factor = tsk_ls_hmm_compute_normalisation_factor_forward;\n self->output = output;\n\n ret = tsk_ls_hmm_run_forward(self, haplotype);\nout:\n return ret;\n}\n\n/****************************************************************\n * Backward Algorithm\n ****************************************************************/\n\nstatic int\ntsk_ls_hmm_next_probability_backward(tsk_ls_hmm_t *self, tsk_id_t site_id, double p_last,\n bool is_match, tsk_id_t TSK_UNUSED(node), double *result)\n{\n const double mu = self->mutation_rate[site_id];\n const double num_alleles = self->num_alleles[site_id];\n double p_e;\n\n p_e = mu;\n if (is_match) {\n p_e = 1 - (num_alleles - 1) * mu;\n }\n *result = p_last * p_e;\n return 0;\n}\n\nstatic int\ntsk_ls_hmm_process_site_backward(tsk_ls_hmm_t *self, const tsk_site_t *site,\n const int32_t haplotype_state, const double normalisation_factor)\n{\n int ret = 0;\n double x, b_last_sum;\n tsk_compressed_matrix_t *output = (tsk_compressed_matrix_t *) self->output;\n tsk_value_transition_t *restrict T = self->transitions;\n const unsigned int precision = (unsigned int) self->precision;\n const double rho = self->recombination_rate[site->id];\n const double n = (double) self->num_samples;\n tsk_size_t j;\n\n /* FIXME!!! We are calling compress twice here because we need to compress\n * immediately before calling store_site in order to filter out -1 nodes,\n * and also (crucially) to ensure that the value transitions are listed\n * in preorder, which we rely on later for decoding.\n *\n * https://github.com/tskit-dev/tskit/issues/2803\n */\n ret = tsk_ls_hmm_compress(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_compressed_matrix_store_site(\n output, site->id, normalisation_factor, (tsk_size_t) self->num_transitions, T);\n if (ret != 0) {\n goto out;\n }\n\n ret = tsk_ls_hmm_update_probabilities(self, site, haplotype_state);\n if (ret != 0) {\n goto out;\n }\n /* DO WE NEED THIS compress?? See above */\n ret = tsk_ls_hmm_compress(self);\n if (ret != 0) {\n goto out;\n }\n tsk_bug_assert(self->num_transitions <= self->num_samples);\n b_last_sum = self->compute_normalisation_factor(self);\n for (j = 0; j < self->num_transitions; j++) {\n tsk_bug_assert(T[j].tree_node != TSK_NULL);\n x = rho * b_last_sum / n + (1 - rho) * T[j].value;\n x /= normalisation_factor;\n T[j].value = tsk_round(x, precision);\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_ls_hmm_run_backward(\n tsk_ls_hmm_t *self, int32_t *haplotype, const double *forward_norm)\n{\n int ret = 0;\n int t_ret;\n const tsk_site_t *sites;\n double s;\n tsk_size_t num_sites;\n tsk_id_t j;\n\n ret = tsk_ls_hmm_reset(self, 1);\n if (ret != 0) {\n goto out;\n }\n\n for (t_ret = tsk_tree_last(&self->tree); t_ret == TSK_TREE_OK;\n t_ret = tsk_tree_prev(&self->tree)) {\n ret = tsk_ls_hmm_update_tree(self, TSK_DIR_REVERSE);\n if (ret != 0) {\n goto out;\n }\n /* tsk_ls_hmm_check_state(self); */\n ret = tsk_tree_get_sites(&self->tree, &sites, &num_sites);\n if (ret != 0) {\n goto out;\n }\n for (j = (tsk_id_t) num_sites - 1; j >= 0; j--) {\n s = forward_norm[sites[j].id];\n if (s <= 0) {\n /* NOTE: I'm not sure if this is the correct interpretation,\n * but norm values of 0 do lead to problems, and this seems\n * like a simple way of guarding against it. We do seem to\n * get norm values of 0 with impossible matches from the fwd\n * matrix.\n */\n ret = tsk_trace_error(TSK_ERR_MATCH_IMPOSSIBLE);\n goto out;\n }\n ret = tsk_ls_hmm_process_site_backward(\n self, &sites[j], haplotype[sites[j].id], s);\n if (ret != 0) {\n goto out;\n }\n }\n }\n /* Set to zero so we can print and check the state OK. */\n self->num_transitions = 0;\n if (t_ret != 0) {\n ret = t_ret;\n goto out;\n }\nout:\n return ret;\n}\n\nint\ntsk_ls_hmm_backward(tsk_ls_hmm_t *self, int32_t *haplotype, const double *forward_norm,\n tsk_compressed_matrix_t *output, tsk_flags_t options)\n{\n int ret = 0;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_compressed_matrix_init(output, self->tree_sequence, 0, 0);\n if (ret != 0) {\n goto out;\n }\n } else {\n if (output->tree_sequence != self->tree_sequence) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n ret = tsk_compressed_matrix_clear(output);\n if (ret != 0) {\n goto out;\n }\n }\n\n self->next_probability = tsk_ls_hmm_next_probability_backward;\n self->compute_normalisation_factor = tsk_ls_hmm_compute_normalisation_factor_forward;\n self->output = output;\n\n ret = tsk_ls_hmm_run_backward(self, haplotype, forward_norm);\nout:\n return ret;\n}\n\n/****************************************************************\n * Viterbi Algorithm\n ****************************************************************/\n\nstatic double\ntsk_ls_hmm_compute_normalisation_factor_viterbi(tsk_ls_hmm_t *self)\n{\n tsk_value_transition_t *restrict T = self->transitions;\n const tsk_id_t num_transitions = (tsk_id_t) self->num_transitions;\n tsk_value_transition_t max_vt;\n tsk_id_t j;\n\n max_vt.value = -1;\n max_vt.tree_node = 0; /* keep compiler happy */\n tsk_bug_assert(num_transitions > 0);\n for (j = 0; j < num_transitions; j++) {\n tsk_bug_assert(T[j].tree_node != TSK_NULL);\n if (T[j].value > max_vt.value) {\n max_vt = T[j];\n }\n }\n return max_vt.value;\n}\n\nstatic int\ntsk_ls_hmm_next_probability_viterbi(tsk_ls_hmm_t *self, tsk_id_t site, double p_last,\n bool is_match, tsk_id_t node, double *result)\n{\n const double rho = self->recombination_rate[site];\n const double mu = self->mutation_rate[site];\n const double num_alleles = self->num_alleles[site];\n const double n = (double) self->num_samples;\n double p_recomb, p_no_recomb, p_t, p_e;\n bool recombination_required = false;\n\n p_no_recomb = p_last * (1 - rho + rho / n);\n p_recomb = rho / n;\n if (p_no_recomb > p_recomb) {\n p_t = p_no_recomb;\n } else {\n p_t = p_recomb;\n recombination_required = true;\n }\n p_e = mu;\n if (is_match) {\n p_e = 1 - (num_alleles - 1) * mu;\n }\n *result = p_t * p_e;\n return tsk_viterbi_matrix_add_recombination_required(\n self->output, site, node, recombination_required);\n}\n\nint\ntsk_ls_hmm_viterbi(tsk_ls_hmm_t *self, int32_t *haplotype, tsk_viterbi_matrix_t *output,\n tsk_flags_t options)\n{\n int ret = 0;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_viterbi_matrix_init(output, self->tree_sequence, 0, 0);\n if (ret != 0) {\n goto out;\n }\n } else {\n if (output->matrix.tree_sequence != self->tree_sequence) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n ret = tsk_viterbi_matrix_clear(output);\n if (ret != 0) {\n goto out;\n }\n }\n\n self->next_probability = tsk_ls_hmm_next_probability_viterbi;\n self->compute_normalisation_factor = tsk_ls_hmm_compute_normalisation_factor_viterbi;\n self->output = output;\n\n ret = tsk_ls_hmm_run_forward(self, haplotype);\nout:\n return ret;\n}\n\n/****************************************************************\n * Compressed matrix\n ****************************************************************/\n\nint\ntsk_compressed_matrix_init(tsk_compressed_matrix_t *self, tsk_treeseq_t *tree_sequence,\n tsk_size_t block_size, tsk_flags_t options)\n{\n int ret = 0;\n\n tsk_memset(self, 0, sizeof(*self));\n self->tree_sequence = tree_sequence;\n self->options = options;\n self->num_sites = tsk_treeseq_get_num_sites(tree_sequence);\n self->num_samples = tsk_treeseq_get_num_samples(tree_sequence);\n self->num_transitions = tsk_malloc(self->num_sites * sizeof(*self->num_transitions));\n self->normalisation_factor\n = tsk_malloc(self->num_sites * sizeof(*self->normalisation_factor));\n self->values = tsk_malloc(self->num_sites * sizeof(*self->values));\n self->nodes = tsk_malloc(self->num_sites * sizeof(*self->nodes));\n if (self->num_transitions == NULL || self->values == NULL || self->nodes == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n if (block_size == 0) {\n block_size = 1 << 20;\n }\n ret = tsk_blkalloc_init(&self->memory, (size_t) block_size);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_compressed_matrix_clear(self);\nout:\n return ret;\n}\n\nint\ntsk_compressed_matrix_free(tsk_compressed_matrix_t *self)\n{\n tsk_blkalloc_free(&self->memory);\n tsk_safe_free(self->num_transitions);\n tsk_safe_free(self->normalisation_factor);\n tsk_safe_free(self->values);\n tsk_safe_free(self->nodes);\n return 0;\n}\n\nint\ntsk_compressed_matrix_clear(tsk_compressed_matrix_t *self)\n{\n tsk_blkalloc_reset(&self->memory);\n tsk_memset(\n self->num_transitions, 0, self->num_sites * sizeof(*self->num_transitions));\n tsk_memset(self->normalisation_factor, 0,\n self->num_sites * sizeof(*self->normalisation_factor));\n return 0;\n}\n\nvoid\ntsk_compressed_matrix_print_state(tsk_compressed_matrix_t *self, FILE *out)\n{\n tsk_size_t l, j;\n\n fprintf(out, \"Compressed matrix for %p\\n\", (void *) self->tree_sequence);\n fprintf(out, \"num_sites = %lld\\n\", (long long) self->num_sites);\n fprintf(out, \"num_samples = %lld\\n\", (long long) self->num_samples);\n for (l = 0; l < self->num_sites; l++) {\n fprintf(out, \"%lld\\ts=%f\\tv=%lld [\", (long long) l,\n self->normalisation_factor[l], (long long) self->num_transitions[l]);\n for (j = 0; j < self->num_transitions[l]; j++) {\n fprintf(\n out, \"(%lld, %f)\", (long long) self->nodes[l][j], self->values[l][j]);\n if (j < self->num_transitions[l] - 1) {\n fprintf(out, \",\");\n } else {\n fprintf(out, \"]\\n\");\n }\n }\n }\n fprintf(out, \"Memory:\\n\");\n tsk_blkalloc_print_state(&self->memory, out);\n}\n\nint\ntsk_compressed_matrix_store_site(tsk_compressed_matrix_t *self, tsk_id_t site,\n double normalisation_factor, tsk_size_t num_transitions,\n const tsk_value_transition_t *transitions)\n{\n int ret = 0;\n tsk_size_t j;\n\n if (site < 0 || site >= (tsk_id_t) self->num_sites) {\n ret = tsk_trace_error(TSK_ERR_SITE_OUT_OF_BOUNDS);\n goto out;\n }\n\n self->num_transitions[site] = num_transitions;\n self->normalisation_factor[site] = normalisation_factor;\n self->nodes[site]\n = tsk_blkalloc_get(&self->memory, (size_t) num_transitions * sizeof(tsk_id_t));\n self->values[site]\n = tsk_blkalloc_get(&self->memory, (size_t) num_transitions * sizeof(double));\n if (self->nodes[site] == NULL || self->values[site] == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n for (j = 0; j < num_transitions; j++) {\n tsk_bug_assert(transitions[j].tree_node >= 0);\n self->values[site][j] = transitions[j].value;\n self->nodes[site][j] = transitions[j].tree_node;\n }\n\nout:\n return ret;\n}\n\nstatic int\ntsk_compressed_matrix_decode_site(tsk_compressed_matrix_t *self, const tsk_tree_t *tree,\n const tsk_id_t site, double *values)\n{\n int ret = 0;\n const tsk_id_t *restrict list_left = tree->left_sample;\n const tsk_id_t *restrict list_right = tree->right_sample;\n const tsk_id_t *restrict list_next = tree->next_sample;\n const tsk_id_t num_nodes = (tsk_id_t) tsk_treeseq_get_num_nodes(self->tree_sequence);\n tsk_size_t j;\n tsk_id_t node, index, stop;\n double value;\n\n for (j = 0; j < self->num_transitions[site]; j++) {\n node = self->nodes[site][j];\n if (node < 0 || node >= num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n value = self->values[site][j];\n index = list_left[node];\n if (index == TSK_NULL) {\n /* It's an error if there are nodes that don't subtend any samples */\n ret = tsk_trace_error(TSK_ERR_BAD_COMPRESSED_MATRIX_NODE);\n goto out;\n }\n stop = list_right[node];\n while (true) {\n values[index] = value;\n if (index == stop) {\n break;\n }\n index = list_next[index];\n }\n }\nout:\n return ret;\n}\n\nint\ntsk_compressed_matrix_decode(tsk_compressed_matrix_t *self, double *values)\n{\n int ret = 0;\n int t_ret;\n tsk_tree_t tree;\n tsk_size_t j, num_tree_sites;\n const tsk_site_t *sites = NULL;\n tsk_id_t site_id;\n double *site_array;\n\n ret = tsk_tree_init(&tree, self->tree_sequence, TSK_SAMPLE_LISTS);\n if (ret != 0) {\n goto out;\n }\n\n for (t_ret = tsk_tree_first(&tree); t_ret == TSK_TREE_OK;\n t_ret = tsk_tree_next(&tree)) {\n ret = tsk_tree_get_sites(&tree, &sites, &num_tree_sites);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_tree_sites; j++) {\n site_id = sites[j].id;\n site_array = values + ((tsk_size_t) site_id) * self->num_samples;\n if (self->num_transitions[site_id] == 0) {\n tsk_memset(site_array, 0, self->num_samples * sizeof(*site_array));\n } else {\n ret = tsk_compressed_matrix_decode_site(\n self, &tree, site_id, site_array);\n if (ret != 0) {\n goto out;\n }\n }\n }\n }\n if (t_ret < 0) {\n ret = t_ret;\n goto out;\n }\nout:\n tsk_tree_free(&tree);\n return ret;\n}\n\n/****************************************************************\n * Viterbi matrix\n ****************************************************************/\n\nstatic int\ntsk_viterbi_matrix_expand_recomb_records(tsk_viterbi_matrix_t *self)\n{\n int ret = 0;\n tsk_recomb_required_record *tmp = tsk_realloc(\n self->recombination_required, self->max_recomb_records * sizeof(*tmp));\n\n if (tmp == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n self->recombination_required = tmp;\nout:\n return ret;\n}\n\nint\ntsk_viterbi_matrix_init(tsk_viterbi_matrix_t *self, tsk_treeseq_t *tree_sequence,\n tsk_size_t block_size, tsk_flags_t options)\n{\n int ret = 0;\n\n tsk_memset(self, 0, sizeof(*self));\n if (block_size == 0) {\n block_size = 1 << 20; /* 1MiB */\n }\n ret = tsk_compressed_matrix_init(&self->matrix, tree_sequence, block_size, options);\n if (ret != 0) {\n goto out;\n }\n\n self->max_recomb_records\n = TSK_MAX(1, block_size / sizeof(tsk_recomb_required_record));\n ret = tsk_viterbi_matrix_expand_recomb_records(self);\n if (ret != 0) {\n goto out;\n }\n /* Add the sentinel at the start to simplify traceback */\n self->recombination_required[0].site = -1;\n\n ret = tsk_viterbi_matrix_clear(self);\nout:\n return ret;\n}\n\nint\ntsk_viterbi_matrix_free(tsk_viterbi_matrix_t *self)\n{\n tsk_compressed_matrix_free(&self->matrix);\n tsk_safe_free(self->recombination_required);\n return 0;\n}\n\nint\ntsk_viterbi_matrix_clear(tsk_viterbi_matrix_t *self)\n{\n self->num_recomb_records = 1;\n tsk_compressed_matrix_clear(&self->matrix);\n return 0;\n}\n\nvoid\ntsk_viterbi_matrix_print_state(tsk_viterbi_matrix_t *self, FILE *out)\n{\n tsk_id_t l, j;\n\n fprintf(out, \"viterbi_matrix\\n\");\n fprintf(out, \"num_recomb_records = %lld\\n\", (long long) self->num_recomb_records);\n fprintf(out, \"max_recomb_records = %lld\\n\", (long long) self->max_recomb_records);\n\n j = 1;\n for (l = 0; l < (tsk_id_t) self->matrix.num_sites; l++) {\n fprintf(out, \"%lld\\t[\", (long long) l);\n while (j < (tsk_id_t) self->num_recomb_records\n && self->recombination_required[j].site == l) {\n fprintf(out, \"(%lld, %d) \", (long long) self->recombination_required[j].node,\n self->recombination_required[j].required);\n j++;\n }\n fprintf(out, \"]\\n\");\n }\n tsk_compressed_matrix_print_state(&self->matrix, out);\n}\n\nTSK_WARN_UNUSED int\ntsk_viterbi_matrix_add_recombination_required(\n tsk_viterbi_matrix_t *self, tsk_id_t site, tsk_id_t node, bool required)\n{\n int ret = 0;\n tsk_recomb_required_record *record;\n\n if (self->num_recomb_records == self->max_recomb_records) {\n self->max_recomb_records *= 2;\n ret = tsk_viterbi_matrix_expand_recomb_records(self);\n if (ret != 0) {\n goto out;\n }\n }\n record = self->recombination_required + self->num_recomb_records;\n record->site = site;\n record->node = node;\n record->required = required;\n self->num_recomb_records++;\nout:\n return ret;\n}\n\nstatic tsk_id_t\ntsk_viterbi_matrix_choose_sample(\n tsk_viterbi_matrix_t *self, tsk_id_t site, tsk_tree_t *tree)\n{\n tsk_id_t ret;\n tsk_id_t u = TSK_NULL;\n const tsk_flags_t *node_flags = self->matrix.tree_sequence->tables->nodes.flags;\n const tsk_size_t num_transitions = self->matrix.num_transitions[site];\n const tsk_id_t *transition_nodes = self->matrix.nodes[site];\n const double *transition_values = self->matrix.values[site];\n double max_value = -1;\n tsk_size_t j;\n tsk_id_t v;\n bool found;\n\n if (num_transitions == 0) {\n ret = tsk_trace_error(TSK_ERR_NULL_VITERBI_MATRIX);\n goto out;\n }\n for (j = 0; j < num_transitions; j++) {\n if (max_value < transition_values[j]) {\n u = transition_nodes[j];\n max_value = transition_values[j];\n }\n }\n tsk_bug_assert(u != TSK_NULL);\n\n while (!(node_flags[u] & TSK_NODE_IS_SAMPLE)) {\n found = false;\n for (v = tree->left_child[u]; v != TSK_NULL; v = tree->right_sib[v]) {\n /* Choose the first child that is not in the list of transition nodes */\n for (j = 0; j < num_transitions; j++) {\n if (transition_nodes[j] == v) {\n break;\n }\n }\n if (j == num_transitions) {\n u = v;\n found = true;\n break;\n }\n }\n /* TODO: should remove this once we're sure this is robust */\n tsk_bug_assert(found);\n }\n ret = u;\nout:\n return ret;\n}\n\nint\ntsk_viterbi_matrix_traceback(\n tsk_viterbi_matrix_t *self, tsk_id_t *path, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_site_t site;\n tsk_id_t u, site_id, current_node;\n tsk_recomb_required_record *rr_record, *rr_record_tmp;\n const tsk_id_t num_sites = (tsk_id_t) self->matrix.num_sites;\n const tsk_id_t num_nodes\n = (tsk_id_t) tsk_treeseq_get_num_nodes(self->matrix.tree_sequence);\n tsk_tree_t tree;\n tsk_id_t *recombination_tree\n = tsk_malloc((size_t) num_nodes * sizeof(*recombination_tree));\n\n ret = tsk_tree_init(&tree, self->matrix.tree_sequence, 0);\n if (ret != 0) {\n goto out;\n }\n if (recombination_tree == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n /* Initialise the path an recombination_tree to contain TSK_NULL */\n tsk_memset(path, 0xff, ((size_t) num_sites) * sizeof(*path));\n tsk_memset(recombination_tree, 0xff, ((size_t) num_nodes) * sizeof(*path));\n\n current_node = TSK_NULL;\n rr_record = &self->recombination_required[self->num_recomb_records - 1];\n ret = tsk_tree_last(&tree);\n if (ret < 0) {\n goto out;\n }\n\n for (site_id = num_sites - 1; site_id >= 0; site_id--) {\n ret = tsk_treeseq_get_site(self->matrix.tree_sequence, site_id, &site);\n if (ret != 0) {\n goto out;\n }\n while (tree.interval.left > site.position) {\n ret = tsk_tree_prev(&tree);\n if (ret < 0) {\n goto out;\n }\n }\n tsk_bug_assert(tree.interval.left <= site.position);\n tsk_bug_assert(site.position < tree.interval.right);\n\n /* Fill in the recombination tree */\n rr_record_tmp = rr_record;\n while (rr_record->site == site.id) {\n recombination_tree[rr_record->node] = rr_record->required;\n rr_record--;\n }\n if (current_node == TSK_NULL) {\n current_node = tsk_viterbi_matrix_choose_sample(self, site.id, &tree);\n if (current_node < 0) {\n ret = (int) current_node;\n goto out;\n }\n }\n path[site.id] = current_node;\n /* Now traverse up the tree from the current node. The\n * first marked node tells us whether we need to recombine */\n u = current_node;\n while (u != TSK_NULL && recombination_tree[u] == TSK_NULL) {\n u = tree.parent[u];\n }\n tsk_bug_assert(u != TSK_NULL);\n if (recombination_tree[u] == 1) {\n /* Switch at the next site */\n current_node = TSK_NULL;\n }\n\n /* Reset in the recombination tree */\n rr_record = rr_record_tmp;\n while (rr_record->site == site.id) {\n recombination_tree[rr_record->node] = TSK_NULL;\n rr_record--;\n }\n }\n ret = 0;\nout:\n tsk_tree_free(&tree);\n tsk_safe_free(recombination_tree);\n return ret;\n}\n"
},
{
"path": "c/tskit/haplotype_matching.h",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2024 Tskit Developers\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#ifndef TSK_HAPLOTYPE_MATCHING_H\n#define TSK_HAPLOTYPE_MATCHING_H\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#include \n\n/* Seems like we might use this somewhere else as well, so putting it into the middle\n * of the flags space */\n#define TSK_ALLELES_ACGT (1 << 16)\n\ntypedef struct {\n tsk_id_t tree_node;\n tsk_id_t value_index;\n double value;\n} tsk_value_transition_t;\n\ntypedef struct {\n tsk_size_t index;\n double value;\n} tsk_argsort_t;\n\ntypedef struct {\n tsk_id_t tree_node;\n tsk_id_t old_state;\n tsk_id_t new_state;\n tsk_id_t transition_parent;\n} tsk_transition_stack_t;\n\ntypedef struct {\n double normalisation_factor;\n double *value;\n tsk_id_t *node;\n tsk_size_t num_values;\n} tsk_site_probability_t;\n\ntypedef struct {\n tsk_treeseq_t *tree_sequence;\n tsk_flags_t options;\n tsk_size_t num_sites;\n tsk_size_t num_samples;\n double *normalisation_factor;\n tsk_size_t *num_transitions;\n double **values;\n tsk_id_t **nodes;\n tsk_blkalloc_t memory;\n} tsk_compressed_matrix_t;\n\ntypedef struct {\n tsk_id_t site;\n tsk_id_t node;\n bool required;\n} tsk_recomb_required_record;\n\ntypedef struct {\n tsk_compressed_matrix_t matrix;\n tsk_recomb_required_record *recombination_required;\n tsk_size_t num_recomb_records;\n tsk_size_t max_recomb_records;\n} tsk_viterbi_matrix_t;\n\ntypedef struct _tsk_ls_hmm_t {\n /* input */\n tsk_treeseq_t *tree_sequence;\n double *recombination_rate;\n double *mutation_rate;\n const char ***alleles;\n unsigned int precision;\n uint32_t *num_alleles;\n tsk_size_t num_samples;\n tsk_size_t num_sites;\n tsk_size_t num_nodes;\n /* state */\n tsk_tree_t tree;\n tsk_id_t *parent;\n /* The probability value transitions on the tree */\n tsk_value_transition_t *transitions;\n tsk_value_transition_t *transitions_copy;\n /* Stack used when distributing transitions on the tree */\n tsk_transition_stack_t *transition_stack;\n /* Map of node_id to index in the transitions list */\n tsk_id_t *transition_index;\n /* Buffer used to argsort the transitions by node time */\n tsk_argsort_t *transition_time_order;\n tsk_size_t num_transitions;\n tsk_size_t max_transitions;\n /* The distinct values in the transitions */\n double *values;\n tsk_size_t num_values;\n tsk_size_t max_values;\n tsk_size_t max_parsimony_words;\n /* Number of machine words per node optimal value set. */\n tsk_size_t num_optimal_value_set_words;\n uint64_t *optimal_value_sets;\n /* The parent transition; used during compression */\n tsk_id_t *transition_parent;\n /* The number of samples directly subtended by a transition */\n tsk_size_t *num_transition_samples;\n int32_t *allelic_state;\n /* Algorithms set these values before they are run */\n int (*next_probability)(\n struct _tsk_ls_hmm_t *, tsk_id_t, double, bool, tsk_id_t, double *);\n double (*compute_normalisation_factor)(struct _tsk_ls_hmm_t *);\n void *output;\n} tsk_ls_hmm_t;\n\n/* TODO constify these APIs */\nint tsk_ls_hmm_init(tsk_ls_hmm_t *self, tsk_treeseq_t *tree_sequence,\n double *recombination_rate, double *mutation_rate, tsk_flags_t options);\nint tsk_ls_hmm_set_precision(tsk_ls_hmm_t *self, unsigned int precision);\nint tsk_ls_hmm_free(tsk_ls_hmm_t *self);\nvoid tsk_ls_hmm_print_state(tsk_ls_hmm_t *self, FILE *out);\nint tsk_ls_hmm_forward(tsk_ls_hmm_t *self, int32_t *haplotype,\n tsk_compressed_matrix_t *output, tsk_flags_t options);\nint tsk_ls_hmm_backward(tsk_ls_hmm_t *self, int32_t *haplotype,\n const double *forward_norm, tsk_compressed_matrix_t *output, tsk_flags_t options);\nint tsk_ls_hmm_viterbi(tsk_ls_hmm_t *self, int32_t *haplotype,\n tsk_viterbi_matrix_t *output, tsk_flags_t options);\n\nint tsk_compressed_matrix_init(tsk_compressed_matrix_t *self,\n tsk_treeseq_t *tree_sequence, tsk_size_t block_size, tsk_flags_t options);\nint tsk_compressed_matrix_free(tsk_compressed_matrix_t *self);\nint tsk_compressed_matrix_clear(tsk_compressed_matrix_t *self);\nvoid tsk_compressed_matrix_print_state(tsk_compressed_matrix_t *self, FILE *out);\nint tsk_compressed_matrix_store_site(tsk_compressed_matrix_t *self, tsk_id_t site,\n double normalisation_factor, tsk_size_t num_transitions,\n const tsk_value_transition_t *transitions);\nint tsk_compressed_matrix_decode(tsk_compressed_matrix_t *self, double *values);\n\nint tsk_viterbi_matrix_init(tsk_viterbi_matrix_t *self, tsk_treeseq_t *tree_sequence,\n tsk_size_t block_size, tsk_flags_t options);\nint tsk_viterbi_matrix_free(tsk_viterbi_matrix_t *self);\nint tsk_viterbi_matrix_clear(tsk_viterbi_matrix_t *self);\nvoid tsk_viterbi_matrix_print_state(tsk_viterbi_matrix_t *self, FILE *out);\nint tsk_viterbi_matrix_add_recombination_required(\n tsk_viterbi_matrix_t *self, tsk_id_t site, tsk_id_t node, bool required);\nint tsk_viterbi_matrix_traceback(\n tsk_viterbi_matrix_t *self, tsk_id_t *path, tsk_flags_t options);\n\n#ifdef __cplusplus\n}\n#endif\n#endif\n"
},
{
"path": "c/tskit/stats.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2018-2025 Tskit Developers\n * Copyright (c) 2016-2017 University of Oxford\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \n#include \n#include \n#include \n\n#include \n\nvoid\ntsk_ld_calc_print_state(const tsk_ld_calc_t *self, FILE *out)\n{\n fprintf(out, \"tree = %p\\n\", (const void *) &self->tree);\n fprintf(out, \"max_sites = %d\\n\", (int) self->max_sites);\n fprintf(out, \"max_distance = %f\\n\", self->max_distance);\n}\n\nint TSK_WARN_UNUSED\ntsk_ld_calc_init(tsk_ld_calc_t *self, const tsk_treeseq_t *tree_sequence)\n{\n int ret = 0;\n tsk_memset(self, 0, sizeof(*self));\n\n ret = tsk_tree_init(&self->tree, tree_sequence, 0);\n if (ret != 0) {\n goto out;\n }\n self->tree_sequence = tree_sequence;\n self->total_samples = tsk_treeseq_get_num_samples(self->tree_sequence);\n\n self->sample_buffer = tsk_malloc(self->total_samples * sizeof(*self->sample_buffer));\n if (self->sample_buffer == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\nout:\n return ret;\n}\n\nint\ntsk_ld_calc_free(tsk_ld_calc_t *self)\n{\n tsk_tree_free(&self->tree);\n tsk_safe_free(self->sample_buffer);\n return 0;\n}\n\nstatic int\ntsk_ld_calc_check_site(tsk_ld_calc_t *TSK_UNUSED(self), const tsk_site_t *site)\n{\n int ret = 0;\n\n /* These are both limitations in the current implementation, there's no\n * fundamental reason why we can't support them */\n if (site->mutations_length != 1) {\n ret = tsk_trace_error(TSK_ERR_ONLY_INFINITE_SITES);\n goto out;\n }\n if (site->ancestral_state_length == site->mutations[0].derived_state_length\n && tsk_memcmp(site->ancestral_state, site->mutations[0].derived_state,\n site->ancestral_state_length)\n == 0) {\n ret = tsk_trace_error(TSK_ERR_SILENT_MUTATIONS_NOT_SUPPORTED);\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_ld_calc_set_focal_samples(tsk_ld_calc_t *self)\n{\n int ret = 0;\n tsk_id_t focal_node = self->focal_site.mutations[0].node;\n\n ret = tsk_tree_track_descendant_samples(&self->tree, focal_node);\n if (ret != 0) {\n goto out;\n }\n self->focal_samples = self->tree.num_tracked_samples[focal_node];\nout:\n return ret;\n}\n\nstatic int\ntsk_ld_calc_initialise(tsk_ld_calc_t *self, tsk_id_t a)\n{\n int ret = 0;\n\n ret = tsk_treeseq_get_site(self->tree_sequence, a, &self->focal_site);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_ld_calc_check_site(self, &self->focal_site);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_tree_seek(&self->tree, self->focal_site.position, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_ld_calc_set_focal_samples(self);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_ld_calc_compute_r2(tsk_ld_calc_t *self, const tsk_site_t *target_site, double *r2)\n{\n const double n = (double) self->total_samples;\n double f_a, f_b, f_ab, D, denom;\n tsk_id_t node;\n int ret = tsk_ld_calc_check_site(self, target_site);\n\n if (ret != 0) {\n goto out;\n }\n node = target_site->mutations[0].node;\n f_a = ((double) self->focal_samples) / n;\n f_b = ((double) self->tree.num_samples[node]) / n;\n f_ab = ((double) self->tree.num_tracked_samples[node]) / n;\n D = f_ab - f_a * f_b;\n denom = f_a * f_b * (1 - f_a) * (1 - f_b);\n *r2 = (D * D) / denom;\nout:\n return ret;\n}\n\nstatic int\ntsk_ld_calc_compute_and_append(\n tsk_ld_calc_t *self, const tsk_site_t *target_site, bool *ret_done)\n{\n int ret = 0;\n double r2;\n double distance = fabs(self->focal_site.position - target_site->position);\n bool done = true;\n\n if (distance <= self->max_distance && self->result_length < self->max_sites) {\n ret = tsk_ld_calc_compute_r2(self, target_site, &r2);\n if (ret != 0) {\n goto out;\n }\n self->result[self->result_length] = r2;\n self->result_length++;\n done = false;\n }\n *ret_done = done;\nout:\n return ret;\n}\n\nstatic int\ntsk_ld_calc_run_forward(tsk_ld_calc_t *self)\n{\n int ret = 0;\n tsk_size_t j;\n bool done = false;\n\n for (j = 0; j < self->tree.sites_length; j++) {\n if (self->tree.sites[j].id > self->focal_site.id) {\n ret = tsk_ld_calc_compute_and_append(self, &self->tree.sites[j], &done);\n if (ret != 0) {\n goto out;\n }\n if (done) {\n break;\n }\n }\n }\n while (((ret = tsk_tree_next(&self->tree)) == TSK_TREE_OK) && !done) {\n for (j = 0; j < self->tree.sites_length; j++) {\n ret = tsk_ld_calc_compute_and_append(self, &self->tree.sites[j], &done);\n if (ret != 0) {\n goto out;\n }\n if (done) {\n break;\n }\n }\n }\n if (ret < 0) {\n goto out;\n }\n ret = 0;\nout:\n return ret;\n}\n\nstatic int\ntsk_ld_calc_run_reverse(tsk_ld_calc_t *self)\n{\n int ret = 0;\n tsk_id_t j;\n bool done = false;\n\n for (j = (tsk_id_t) self->tree.sites_length - 1; j >= 0; j--) {\n if (self->tree.sites[j].id < self->focal_site.id) {\n ret = tsk_ld_calc_compute_and_append(self, &self->tree.sites[j], &done);\n if (ret != 0) {\n goto out;\n }\n if (done) {\n break;\n }\n }\n }\n while (((ret = tsk_tree_prev(&self->tree)) == TSK_TREE_OK) && !done) {\n for (j = (tsk_id_t) self->tree.sites_length - 1; j >= 0; j--) {\n ret = tsk_ld_calc_compute_and_append(self, &self->tree.sites[j], &done);\n if (ret != 0) {\n goto out;\n }\n if (done) {\n break;\n }\n }\n }\n if (ret < 0) {\n goto out;\n }\n ret = 0;\nout:\n return ret;\n}\n\nint\ntsk_ld_calc_get_r2(tsk_ld_calc_t *self, tsk_id_t a, tsk_id_t b, double *r2)\n{\n int ret = 0;\n tsk_site_t target_site;\n\n ret = tsk_ld_calc_initialise(self, a);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_get_site(self->tree_sequence, b, &target_site);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_tree_seek(&self->tree, target_site.position, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_ld_calc_compute_r2(self, &target_site, r2);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nint\ntsk_ld_calc_get_r2_array(tsk_ld_calc_t *self, tsk_id_t a, int direction,\n tsk_size_t max_sites, double max_distance, double *r2, tsk_size_t *num_r2_values)\n{\n int ret = tsk_ld_calc_initialise(self, a);\n\n if (ret != 0) {\n goto out;\n }\n\n self->max_sites = max_sites;\n self->max_distance = max_distance;\n self->result_length = 0;\n self->result = r2;\n\n if (direction == TSK_DIR_FORWARD) {\n ret = tsk_ld_calc_run_forward(self);\n } else if (direction == TSK_DIR_REVERSE) {\n ret = tsk_ld_calc_run_reverse(self);\n } else {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n }\n if (ret != 0) {\n goto out;\n }\n *num_r2_values = self->result_length;\nout:\n return ret;\n}\n"
},
{
"path": "c/tskit/stats.h",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2021 Tskit Developers\n * Copyright (c) 2016-2017 University of Oxford\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#ifndef TSK_STATS_H\n#define TSK_STATS_H\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#include \n\ntypedef struct {\n const tsk_treeseq_t *tree_sequence;\n tsk_site_t focal_site;\n tsk_size_t total_samples;\n tsk_size_t focal_samples;\n double max_distance;\n tsk_size_t max_sites;\n tsk_tree_t tree;\n tsk_id_t *sample_buffer;\n double *result;\n tsk_size_t result_length;\n} tsk_ld_calc_t;\n\nint tsk_ld_calc_init(tsk_ld_calc_t *self, const tsk_treeseq_t *tree_sequence);\nint tsk_ld_calc_free(tsk_ld_calc_t *self);\nvoid tsk_ld_calc_print_state(const tsk_ld_calc_t *self, FILE *out);\nint tsk_ld_calc_get_r2(tsk_ld_calc_t *self, tsk_id_t a, tsk_id_t b, double *r2);\nint tsk_ld_calc_get_r2_array(tsk_ld_calc_t *self, tsk_id_t a, int direction,\n tsk_size_t max_sites, double max_distance, double *r2, tsk_size_t *num_r2_values);\n\n#ifdef __cplusplus\n}\n#endif\n#endif\n"
},
{
"path": "c/tskit/tables.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2025 Tskit Developers\n * Copyright (c) 2017-2018 University of Oxford\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#define TABLE_SEP \"-----------------------------------------\\n\"\n\n#define TSK_COL_OPTIONAL (1 << 0)\n\ntypedef struct {\n const char *name;\n void **array_dest;\n int type;\n tsk_flags_t options;\n} read_table_col_t;\n\ntypedef struct {\n const char *name;\n void **data_array_dest;\n tsk_size_t *data_len_dest;\n int data_type;\n tsk_size_t **offset_array_dest;\n tsk_flags_t options;\n} read_table_ragged_col_t;\n\ntypedef struct {\n const char *name;\n void **array_dest;\n tsk_size_t *len_dest;\n int type;\n tsk_flags_t options;\n} read_table_property_t;\n\ntypedef struct {\n const char *name;\n const void *array;\n tsk_size_t len;\n int type;\n} write_table_col_t;\n\ntypedef struct {\n const char *name;\n const void *data_array;\n tsk_size_t data_len;\n int data_type;\n const tsk_size_t *offset_array;\n tsk_size_t num_rows;\n} write_table_ragged_col_t;\n\n/* Returns true if adding the specified number of rows would result in overflow.\n * Tables can support indexes from 0 to TSK_MAX_ID, and therefore could have at most\n * TSK_MAX_ID + 1 rows. However we limit to TSK_MAX_ID rows so that counts of rows\n * can fit in a tsk_id_t. */\nstatic bool\ncheck_table_overflow(tsk_size_t current_size, tsk_size_t additional_rows)\n{\n tsk_size_t max_val = TSK_MAX_ID;\n return additional_rows > max_val || current_size > (max_val - additional_rows);\n}\n\n/* Returns true if adding the specified number of elements would result in overflow\n * of an offset column.\n */\nstatic bool\ncheck_offset_overflow(tsk_size_t current_size, tsk_size_t additional_elements)\n{\n tsk_size_t max_val = TSK_MAX_SIZE;\n return additional_elements > max_val\n || current_size > (max_val - additional_elements);\n}\n\n#define TSK_NUM_ROWS_UNSET ((tsk_size_t) - 1)\n#define TSK_MAX_COL_NAME_LEN 64\n\nstatic int\nread_table_cols(kastore_t *store, tsk_size_t *num_rows, read_table_col_t *cols,\n tsk_flags_t TSK_UNUSED(flags))\n{\n int ret = 0;\n size_t len;\n int type;\n read_table_col_t *col;\n\n for (col = cols; col->name != NULL; col++) {\n ret = kastore_containss(store, col->name);\n if (ret < 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n if (ret == 1) {\n ret = kastore_gets(store, col->name, col->array_dest, &len, &type);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n if (*num_rows == TSK_NUM_ROWS_UNSET) {\n *num_rows = (tsk_size_t) len;\n } else {\n if (*num_rows != (tsk_size_t) len) {\n ret = tsk_trace_error(TSK_ERR_FILE_FORMAT);\n goto out;\n }\n }\n if (type != col->type) {\n ret = tsk_trace_error(TSK_ERR_BAD_COLUMN_TYPE);\n goto out;\n }\n } else if (!(col->options & TSK_COL_OPTIONAL)) {\n ret = tsk_trace_error(TSK_ERR_REQUIRED_COL_NOT_FOUND);\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int\ncast_offset_array(read_table_ragged_col_t *col, uint32_t *source, tsk_size_t num_rows)\n{\n int ret = 0;\n tsk_size_t len = num_rows + 1;\n tsk_size_t j;\n uint64_t *dest = tsk_malloc(len * sizeof(*dest));\n\n if (dest == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n *col->offset_array_dest = dest;\n for (j = 0; j < len; j++) {\n dest[j] = source[j];\n }\nout:\n return ret;\n}\n\nstatic int\nread_table_ragged_cols(kastore_t *store, tsk_size_t *num_rows,\n read_table_ragged_col_t *cols, tsk_flags_t TSK_UNUSED(flags))\n{\n int ret = 0;\n size_t data_len = 0; // initial value unused, just to keep the compiler happy.\n size_t offset_len;\n int type;\n read_table_ragged_col_t *col;\n char offset_col_name[TSK_MAX_COL_NAME_LEN];\n bool data_col_present, offset_col_present;\n void *store_offset_array = NULL;\n tsk_size_t *offset_array;\n\n for (col = cols; col->name != NULL; col++) {\n ret = kastore_containss(store, col->name);\n if (ret < 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n data_col_present = false;\n if (ret == 1) {\n ret = kastore_gets(store, col->name, col->data_array_dest, &data_len, &type);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n if (type != col->data_type) {\n ret = tsk_trace_error(TSK_ERR_BAD_COLUMN_TYPE);\n goto out;\n }\n *col->data_len_dest = (tsk_size_t) data_len;\n data_col_present = true;\n } else if (!(col->options & TSK_COL_OPTIONAL)) {\n ret = tsk_trace_error(TSK_ERR_REQUIRED_COL_NOT_FOUND);\n goto out;\n }\n\n assert(strlen(col->name) + strlen(\"_offset\") + 2 < sizeof(offset_col_name));\n strcpy(offset_col_name, col->name);\n strcat(offset_col_name, \"_offset\");\n\n ret = kastore_containss(store, offset_col_name);\n if (ret < 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n offset_col_present = ret == 1;\n if (offset_col_present != data_col_present) {\n ret = tsk_trace_error(TSK_ERR_BOTH_COLUMNS_REQUIRED);\n goto out;\n }\n if (offset_col_present) {\n ret = kastore_gets(\n store, offset_col_name, &store_offset_array, &offset_len, &type);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n /* A table with zero rows will still have an offset length of 1;\n * catching this here prevents underflows in the logic below */\n if (offset_len == 0) {\n ret = tsk_trace_error(TSK_ERR_FILE_FORMAT);\n goto out;\n }\n /* Some tables have only ragged columns */\n if (*num_rows == TSK_NUM_ROWS_UNSET) {\n *num_rows = (tsk_size_t) offset_len - 1;\n } else {\n if (*num_rows != (tsk_size_t) offset_len - 1) {\n ret = tsk_trace_error(TSK_ERR_FILE_FORMAT);\n goto out;\n }\n }\n if (type == KAS_UINT64) {\n *col->offset_array_dest = (uint64_t *) store_offset_array;\n store_offset_array = NULL;\n } else if (type == KAS_UINT32) {\n ret = cast_offset_array(col, (uint32_t *) store_offset_array, *num_rows);\n if (ret != 0) {\n goto out;\n }\n tsk_safe_free(store_offset_array);\n store_offset_array = NULL;\n } else {\n ret = tsk_trace_error(TSK_ERR_BAD_COLUMN_TYPE);\n goto out;\n }\n offset_array = *col->offset_array_dest;\n if (offset_array[*num_rows] != (tsk_size_t) data_len) {\n ret = tsk_trace_error(TSK_ERR_BAD_OFFSET);\n goto out;\n }\n }\n }\nout:\n tsk_safe_free(store_offset_array);\n return ret;\n}\n\nstatic int\nread_table_properties(\n kastore_t *store, read_table_property_t *properties, tsk_flags_t TSK_UNUSED(flags))\n{\n int ret = 0;\n size_t len;\n int type;\n read_table_property_t *property;\n\n for (property = properties; property->name != NULL; property++) {\n ret = kastore_containss(store, property->name);\n if (ret < 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n if (ret == 1) {\n ret = kastore_gets(store, property->name, property->array_dest, &len, &type);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n assert(ret != 0); /* Tell static analysers that we're handling errors */\n goto out;\n }\n if (type != property->type) {\n ret = tsk_trace_error(TSK_ERR_BAD_COLUMN_TYPE);\n goto out;\n }\n *property->len_dest = (tsk_size_t) len;\n }\n assert(property->options & TSK_COL_OPTIONAL);\n }\nout:\n return ret;\n}\n\nstatic int\nread_table(kastore_t *store, tsk_size_t *num_rows, read_table_col_t *cols,\n read_table_ragged_col_t *ragged_cols, read_table_property_t *properties,\n tsk_flags_t options)\n{\n int ret = 0;\n\n *num_rows = TSK_NUM_ROWS_UNSET;\n if (cols != NULL) {\n ret = read_table_cols(store, num_rows, cols, options);\n if (ret != 0) {\n goto out;\n }\n }\n if (ragged_cols != NULL) {\n ret = read_table_ragged_cols(store, num_rows, ragged_cols, options);\n if (ret != 0) {\n goto out;\n }\n }\n if (*num_rows == TSK_NUM_ROWS_UNSET) {\n ret = tsk_trace_error(TSK_ERR_FILE_FORMAT);\n goto out;\n }\n if (properties != NULL) {\n ret = read_table_properties(store, properties, options);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic void\nfree_read_table_mem(read_table_col_t *cols, read_table_ragged_col_t *ragged_cols,\n read_table_property_t *properties)\n{\n read_table_col_t *col;\n read_table_ragged_col_t *ragged_col;\n read_table_property_t *property;\n\n if (cols != NULL) {\n for (col = cols; col->name != NULL; col++) {\n tsk_safe_free(*(col->array_dest));\n }\n }\n if (ragged_cols != NULL) {\n for (ragged_col = ragged_cols; ragged_col->name != NULL; ragged_col++) {\n tsk_safe_free(*(ragged_col->data_array_dest));\n tsk_safe_free(*(ragged_col->offset_array_dest));\n }\n }\n if (properties != NULL) {\n for (property = properties; property->name != NULL; property++) {\n tsk_safe_free(*(property->array_dest));\n }\n }\n}\n\nstatic int\nwrite_offset_col(\n kastore_t *store, const write_table_ragged_col_t *col, tsk_flags_t options)\n{\n int ret = 0;\n char offset_col_name[TSK_MAX_COL_NAME_LEN];\n uint32_t *offset32 = NULL;\n tsk_size_t len = col->num_rows + 1;\n tsk_size_t j;\n int32_t put_flags = 0;\n int type;\n const void *data;\n bool needs_64 = col->offset_array[col->num_rows] > UINT32_MAX;\n\n assert(strlen(col->name) + strlen(\"_offset\") + 2 < sizeof(offset_col_name));\n strcpy(offset_col_name, col->name);\n strcat(offset_col_name, \"_offset\");\n\n if (options & TSK_DUMP_FORCE_OFFSET_64 || needs_64) {\n type = KAS_UINT64;\n data = col->offset_array;\n put_flags = KAS_BORROWS_ARRAY;\n } else {\n offset32 = tsk_malloc(len * sizeof(*offset32));\n if (offset32 == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n for (j = 0; j < len; j++) {\n offset32[j] = (uint32_t) col->offset_array[j];\n }\n type = KAS_UINT32;\n data = offset32;\n /* We've just allocated a temp buffer, so kas can't borrow so leave put_flags=0*/\n }\n ret = kastore_puts(store, offset_col_name, data, (size_t) len, type, put_flags);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\nout:\n tsk_safe_free(offset32);\n return ret;\n}\n\nstatic int\nwrite_table_ragged_cols(\n kastore_t *store, const write_table_ragged_col_t *write_cols, tsk_flags_t options)\n{\n int ret = 0;\n const write_table_ragged_col_t *col;\n\n for (col = write_cols; col->name != NULL; col++) {\n ret = kastore_puts(store, col->name, col->data_array, (size_t) col->data_len,\n col->data_type, KAS_BORROWS_ARRAY);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n ret = write_offset_col(store, col, options);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int\nwrite_table_cols(kastore_t *store, const write_table_col_t *write_cols,\n tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n const write_table_col_t *col;\n\n for (col = write_cols; col->name != NULL; col++) {\n ret = kastore_puts(store, col->name, col->array, (size_t) col->len, col->type,\n KAS_BORROWS_ARRAY);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int\nwrite_table(kastore_t *store, const write_table_col_t *cols,\n const write_table_ragged_col_t *ragged_cols, tsk_flags_t options)\n{\n int ret = write_table_cols(store, cols, options);\n\n if (ret != 0) {\n goto out;\n }\n ret = write_table_ragged_cols(store, ragged_cols, options);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\n/* Checks that the specified list of offsets is well-formed. */\nstatic int\ncheck_offsets(\n tsk_size_t num_rows, const tsk_size_t *offsets, tsk_size_t length, bool check_length)\n{\n int ret = 0;\n tsk_size_t j;\n\n if (offsets[0] != 0) {\n ret = tsk_trace_error(TSK_ERR_BAD_OFFSET);\n goto out;\n }\n if (check_length && offsets[num_rows] != length) {\n ret = tsk_trace_error(TSK_ERR_BAD_OFFSET);\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n if (offsets[j] > offsets[j + 1]) {\n ret = tsk_trace_error(TSK_ERR_BAD_OFFSET);\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nstatic int\ncalculate_max_rows(tsk_size_t num_rows, tsk_size_t max_rows,\n tsk_size_t max_rows_increment, tsk_size_t additional_rows,\n tsk_size_t *ret_new_max_rows)\n{\n tsk_size_t new_max_rows;\n int ret = 0;\n\n if (check_table_overflow(num_rows, additional_rows)) {\n ret = tsk_trace_error(TSK_ERR_TABLE_OVERFLOW);\n goto out;\n }\n\n if (num_rows + additional_rows <= max_rows) {\n new_max_rows = max_rows;\n } else {\n if (max_rows_increment == 0) {\n /* Doubling by default */\n new_max_rows = TSK_MIN(max_rows * 2, TSK_MAX_ID + (tsk_size_t) 1);\n /* Add some constraints to prevent very small allocations */\n if (new_max_rows < 1024) {\n new_max_rows = 1024;\n }\n /* Prevent allocating more than ~2 million additional rows unless needed*/\n if (new_max_rows - max_rows > 2097152) {\n new_max_rows = max_rows + 2097152;\n }\n } else {\n /* Use user increment value */\n if (check_table_overflow(max_rows, max_rows_increment)) {\n ret = tsk_trace_error(TSK_ERR_TABLE_OVERFLOW);\n goto out;\n }\n new_max_rows = max_rows + max_rows_increment;\n }\n new_max_rows = TSK_MAX(new_max_rows, num_rows + additional_rows);\n }\n *ret_new_max_rows = new_max_rows;\nout:\n return ret;\n}\n\nstatic int\ncalculate_max_length(tsk_size_t current_length, tsk_size_t max_length,\n tsk_size_t max_length_increment, tsk_size_t additional_length,\n tsk_size_t *ret_new_max_length)\n{\n tsk_size_t new_max_length;\n int ret = 0;\n\n if (check_offset_overflow(current_length, additional_length)) {\n ret = tsk_trace_error(TSK_ERR_COLUMN_OVERFLOW);\n goto out;\n }\n\n if (current_length + additional_length <= max_length) {\n new_max_length = max_length;\n } else {\n if (max_length_increment == 0) {\n /* Doubling by default */\n new_max_length = TSK_MIN(max_length * 2, TSK_MAX_SIZE);\n /* Add some constraints to prevent very small allocations */\n if (new_max_length < 65536) {\n new_max_length = 65536;\n }\n /* Prevent allocating more than 100MB additional unless needed*/\n if (new_max_length - max_length > 104857600) {\n new_max_length = max_length + 104857600;\n }\n new_max_length = TSK_MAX(new_max_length, current_length + additional_length);\n } else {\n /* Use user increment value */\n if (check_offset_overflow(max_length, max_length_increment)) {\n /* Here we could allocate to the maximum size.\n * Instead we are erroring out as this is much easier to test.\n * The cost is that (at most) the last \"max_length_increment\"-1\n * bytes of the possible array space can't be used. */\n ret = tsk_trace_error(TSK_ERR_COLUMN_OVERFLOW);\n goto out;\n }\n new_max_length = max_length + max_length_increment;\n }\n new_max_length = TSK_MAX(new_max_length, current_length + additional_length);\n }\n *ret_new_max_length = new_max_length;\nout:\n return ret;\n}\n\nstatic int\nexpand_column(void **column, tsk_size_t new_max_rows, size_t element_size)\n{\n int ret = 0;\n void *tmp;\n\n tmp = tsk_realloc((void **) *column, new_max_rows * element_size);\n if (tmp == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n *column = tmp;\nout:\n return ret;\n}\n\nstatic int\nexpand_ragged_column(tsk_size_t current_length, tsk_size_t additional_length,\n tsk_size_t max_length_increment, tsk_size_t *max_length, void **column,\n size_t element_size)\n{\n int ret = 0;\n tsk_size_t new_max_length;\n\n ret = calculate_max_length(current_length, *max_length, max_length_increment,\n additional_length, &new_max_length);\n if (ret != 0) {\n goto out;\n }\n\n if (new_max_length > *max_length) {\n ret = expand_column(column, new_max_length, element_size);\n if (ret != 0) {\n goto out;\n }\n *max_length = new_max_length;\n }\nout:\n return ret;\n}\n\n/* TODO rename to copy_string or replace_and_copy_string */\nstatic int\nreplace_string(\n char **str, tsk_size_t *len, const char *new_str, const tsk_size_t new_len)\n{\n int ret = 0;\n tsk_safe_free(*str);\n *str = NULL;\n *len = new_len;\n if (new_len > 0) {\n *str = tsk_malloc(new_len * sizeof(char));\n if (*str == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memcpy(*str, new_str, new_len * sizeof(char));\n }\nout:\n return ret;\n}\n\nstatic int\ntakeset_string(char **str, tsk_size_t *len, char *new_str, const tsk_size_t new_len)\n{\n tsk_safe_free(*str);\n *str = new_str;\n *len = new_len;\n return 0;\n}\n\nstatic int\nalloc_empty_ragged_column(tsk_size_t num_rows, void **data_col, tsk_size_t **offset_col)\n{\n int ret = 0;\n\n *data_col = tsk_malloc(1);\n *offset_col = tsk_calloc(num_rows + 1, sizeof(tsk_size_t));\n if (*data_col == NULL || *offset_col == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int\ncheck_ragged_column(tsk_size_t num_rows, void *data, tsk_size_t *offset)\n{\n int ret = 0;\n if ((data == NULL) != (offset == NULL)) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if (data != NULL) {\n ret = check_offsets(num_rows, offset, 0, false);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int\ntakeset_ragged_column(tsk_size_t num_rows, void *data, tsk_size_t *offset,\n void **data_dest, tsk_size_t **offset_dest, tsk_size_t *length_dest)\n{\n int ret = 0;\n if (data == NULL) {\n ret = alloc_empty_ragged_column(num_rows, (void *) data_dest, offset_dest);\n if (ret != 0) {\n goto out;\n }\n } else {\n *data_dest = data;\n *offset_dest = offset;\n }\n *length_dest = (*offset_dest)[num_rows];\nout:\n return ret;\n}\n\nstatic int\ntakeset_optional_id_column(tsk_size_t num_rows, tsk_id_t *input, tsk_id_t **dest)\n{\n int ret = 0;\n tsk_size_t buffsize;\n tsk_id_t *buff;\n\n if (input == NULL) {\n buffsize = num_rows * sizeof(*buff);\n buff = tsk_malloc(buffsize);\n if (buff == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n *dest = buff;\n tsk_memset(buff, 0xff, buffsize);\n } else {\n *dest = input;\n }\nout:\n return ret;\n}\n\nstatic int\nwrite_metadata_schema_header(\n FILE *out, const char *metadata_schema, tsk_size_t metadata_schema_length)\n{\n const char *fmt = \"#metadata_schema#\\n\"\n \"%.*s\\n\"\n \"#end#metadata_schema\\n\" TABLE_SEP;\n return fprintf(out, fmt, (int) metadata_schema_length, metadata_schema);\n}\n\n/* Utilities for in-place subsetting columns */\n\nstatic tsk_size_t\ncount_true(tsk_size_t num_rows, const tsk_bool_t *restrict keep)\n{\n tsk_size_t j;\n tsk_size_t count = 0;\n\n for (j = 0; j < num_rows; j++) {\n if (keep[j]) {\n count++;\n }\n }\n return count;\n}\n\nstatic void\nkeep_mask_to_id_map(\n tsk_size_t num_rows, const tsk_bool_t *restrict keep, tsk_id_t *restrict id_map)\n{\n tsk_size_t j;\n tsk_id_t next_id = 0;\n\n for (j = 0; j < num_rows; j++) {\n id_map[j] = TSK_NULL;\n if (keep[j]) {\n id_map[j] = next_id;\n next_id++;\n }\n }\n}\n\nstatic tsk_size_t\nsubset_remap_id_column(tsk_id_t *restrict column, tsk_size_t num_rows,\n const tsk_bool_t *restrict keep, const tsk_id_t *restrict id_map)\n{\n tsk_size_t j, k;\n tsk_id_t value;\n\n k = 0;\n for (j = 0; j < num_rows; j++) {\n if (keep[j]) {\n value = column[j];\n if (value != TSK_NULL) {\n value = id_map[value];\n }\n column[k] = value;\n k++;\n }\n }\n return k;\n}\n\n/* Trigger warning: C++ programmers should look away... This may be one of the\n * few cases where some macro funkiness is warranted, as these are exact\n * duplicates of the same function with just the type of the column\n * parameter changed. */\n\nstatic tsk_size_t\nsubset_id_column(\n tsk_id_t *restrict column, tsk_size_t num_rows, const tsk_bool_t *restrict keep)\n{\n tsk_size_t j, k;\n\n k = 0;\n for (j = 0; j < num_rows; j++) {\n if (keep[j]) {\n column[k] = column[j];\n k++;\n }\n }\n return k;\n}\n\nstatic tsk_size_t\nsubset_flags_column(\n tsk_flags_t *restrict column, tsk_size_t num_rows, const tsk_bool_t *restrict keep)\n{\n tsk_size_t j, k;\n\n k = 0;\n for (j = 0; j < num_rows; j++) {\n if (keep[j]) {\n column[k] = column[j];\n k++;\n }\n }\n return k;\n}\n\nstatic tsk_size_t\nsubset_double_column(\n double *restrict column, tsk_size_t num_rows, const tsk_bool_t *restrict keep)\n{\n tsk_size_t j, k;\n\n k = 0;\n for (j = 0; j < num_rows; j++) {\n if (keep[j]) {\n column[k] = column[j];\n k++;\n }\n }\n return k;\n}\n\nstatic tsk_size_t\nsubset_ragged_char_column(char *restrict data, tsk_size_t *restrict offset_col,\n tsk_size_t num_rows, const tsk_bool_t *restrict keep)\n{\n tsk_size_t j, k, i, offset;\n\n k = 0;\n offset = 0;\n for (j = 0; j < num_rows; j++) {\n if (keep[j]) {\n offset_col[k] = offset;\n /* Note: Unclear whether it's worth calling memcpy instead here?\n * Need to be careful since the regions are overlapping */\n for (i = offset_col[j]; i < offset_col[j + 1]; i++) {\n data[offset] = data[i];\n offset++;\n }\n k++;\n }\n }\n offset_col[k] = offset;\n return offset;\n}\n\nstatic tsk_size_t\nsubset_ragged_double_column(double *restrict data, tsk_size_t *restrict offset_col,\n tsk_size_t num_rows, const tsk_bool_t *restrict keep)\n{\n tsk_size_t j, k, i, offset;\n\n k = 0;\n offset = 0;\n for (j = 0; j < num_rows; j++) {\n if (keep[j]) {\n offset_col[k] = offset;\n /* Note: Unclear whether it's worth calling memcpy instead here?\n * Need to be careful since the regions are overlapping */\n for (i = offset_col[j]; i < offset_col[j + 1]; i++) {\n data[offset] = data[i];\n offset++;\n }\n k++;\n }\n }\n offset_col[k] = offset;\n return offset;\n}\n\nstatic tsk_size_t\nsubset_remap_ragged_id_column(tsk_id_t *restrict data, tsk_size_t *restrict offset_col,\n tsk_size_t num_rows, const tsk_bool_t *restrict keep,\n const tsk_id_t *restrict id_map)\n{\n tsk_size_t j, k, i, offset;\n tsk_id_t di;\n\n k = 0;\n offset = 0;\n for (j = 0; j < num_rows; j++) {\n if (keep[j]) {\n offset_col[k] = offset;\n for (i = offset_col[j]; i < offset_col[j + 1]; i++) {\n di = data[i];\n if (di != TSK_NULL) {\n di = id_map[di];\n }\n data[offset] = di;\n offset++;\n }\n k++;\n }\n }\n offset_col[k] = offset;\n return offset;\n}\n\n/*************************\n * reference sequence\n *************************/\n\nint\ntsk_reference_sequence_init(\n tsk_reference_sequence_t *self, tsk_flags_t TSK_UNUSED(options))\n{\n tsk_memset(self, 0, sizeof(*self));\n return 0;\n}\n\nint\ntsk_reference_sequence_free(tsk_reference_sequence_t *self)\n{\n tsk_safe_free(self->data);\n tsk_safe_free(self->url);\n tsk_safe_free(self->metadata);\n tsk_safe_free(self->metadata_schema);\n return 0;\n}\n\nbool\ntsk_reference_sequence_is_null(const tsk_reference_sequence_t *self)\n{\n return self->data_length == 0 && self->url_length == 0 && self->metadata_length == 0\n && self->metadata_schema_length == 0;\n}\n\nbool\ntsk_reference_sequence_equals(const tsk_reference_sequence_t *self,\n const tsk_reference_sequence_t *other, tsk_flags_t options)\n{\n int ret\n = self->data_length == other->data_length\n && self->url_length == other->url_length\n && tsk_memcmp(self->data, other->data, self->data_length * sizeof(char)) == 0\n && tsk_memcmp(self->url, other->url, self->url_length * sizeof(char)) == 0;\n\n if (!(options & TSK_CMP_IGNORE_METADATA)) {\n ret = ret && self->metadata_length == other->metadata_length\n && self->metadata_schema_length == other->metadata_schema_length\n && tsk_memcmp(self->metadata, other->metadata,\n self->metadata_length * sizeof(char))\n == 0\n && tsk_memcmp(self->metadata_schema, other->metadata_schema,\n self->metadata_schema_length * sizeof(char))\n == 0;\n }\n return ret;\n}\n\nint\ntsk_reference_sequence_copy(const tsk_reference_sequence_t *self,\n tsk_reference_sequence_t *dest, tsk_flags_t options)\n{\n int ret = 0;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_reference_sequence_init(dest, 0);\n if (ret != 0) {\n goto out;\n }\n }\n\n if (tsk_reference_sequence_is_null(self)) {\n /* This is a simple way to get any input into the NULL state */\n tsk_reference_sequence_free(dest);\n } else {\n ret = tsk_reference_sequence_set_data(dest, self->data, self->data_length);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_reference_sequence_set_url(dest, self->url, self->url_length);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_reference_sequence_set_metadata(\n dest, self->metadata, self->metadata_length);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_reference_sequence_set_metadata_schema(\n dest, self->metadata_schema, self->metadata_schema_length);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nint\ntsk_reference_sequence_set_data(\n tsk_reference_sequence_t *self, const char *data, tsk_size_t data_length)\n{\n return replace_string(&self->data, &self->data_length, data, data_length);\n}\n\nint\ntsk_reference_sequence_set_url(\n tsk_reference_sequence_t *self, const char *url, tsk_size_t url_length)\n{\n return replace_string(&self->url, &self->url_length, url, url_length);\n}\n\nint\ntsk_reference_sequence_set_metadata(\n tsk_reference_sequence_t *self, const char *metadata, tsk_size_t metadata_length)\n{\n return replace_string(\n &self->metadata, &self->metadata_length, metadata, metadata_length);\n}\n\nint\ntsk_reference_sequence_set_metadata_schema(tsk_reference_sequence_t *self,\n const char *metadata_schema, tsk_size_t metadata_schema_length)\n{\n return replace_string(&self->metadata_schema, &self->metadata_schema_length,\n metadata_schema, metadata_schema_length);\n}\n\nint\ntsk_reference_sequence_takeset_data(\n tsk_reference_sequence_t *self, char *data, tsk_size_t data_length)\n{\n return takeset_string(&self->data, &self->data_length, data, data_length);\n}\n\nint\ntsk_reference_sequence_takeset_metadata(\n tsk_reference_sequence_t *self, char *metadata, tsk_size_t metadata_length)\n{\n return takeset_string(\n &self->metadata, &self->metadata_length, metadata, metadata_length);\n}\n\n/*************************\n * individual table\n *************************/\n\nstatic void\ntsk_individual_table_free_columns(tsk_individual_table_t *self)\n{\n tsk_safe_free(self->flags);\n tsk_safe_free(self->location);\n tsk_safe_free(self->location_offset);\n tsk_safe_free(self->parents);\n tsk_safe_free(self->parents_offset);\n tsk_safe_free(self->metadata);\n tsk_safe_free(self->metadata_offset);\n}\n\nint\ntsk_individual_table_free(tsk_individual_table_t *self)\n{\n tsk_individual_table_free_columns(self);\n tsk_safe_free(self->metadata_schema);\n return 0;\n}\n\nstatic int\ntsk_individual_table_expand_main_columns(\n tsk_individual_table_t *self, tsk_size_t additional_rows)\n{\n int ret = 0;\n tsk_size_t new_max_rows;\n\n ret = calculate_max_rows(self->num_rows, self->max_rows, self->max_rows_increment,\n additional_rows, &new_max_rows);\n if (ret != 0) {\n goto out;\n }\n if ((self->num_rows + additional_rows) > self->max_rows) {\n ret = expand_column((void **) &self->flags, new_max_rows, sizeof(tsk_flags_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column(\n (void **) &self->location_offset, new_max_rows + 1, sizeof(tsk_size_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column(\n (void **) &self->parents_offset, new_max_rows + 1, sizeof(tsk_size_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column(\n (void **) &self->metadata_offset, new_max_rows + 1, sizeof(tsk_size_t));\n if (ret != 0) {\n goto out;\n }\n self->max_rows = new_max_rows;\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_individual_table_expand_location(\n tsk_individual_table_t *self, tsk_size_t additional_length)\n{\n return expand_ragged_column(self->location_length, additional_length,\n self->max_location_length_increment, &self->max_location_length,\n (void **) &self->location, sizeof(*self->location));\n}\n\nstatic int\ntsk_individual_table_expand_parents(\n tsk_individual_table_t *self, tsk_size_t additional_length)\n{\n return expand_ragged_column(self->parents_length, additional_length,\n self->max_parents_length_increment, &self->max_parents_length,\n (void **) &self->parents, sizeof(*self->parents));\n}\n\nstatic int\ntsk_individual_table_expand_metadata(\n tsk_individual_table_t *self, tsk_size_t additional_length)\n{\n return expand_ragged_column(self->metadata_length, additional_length,\n self->max_metadata_length_increment, &self->max_metadata_length,\n (void **) &self->metadata, sizeof(*self->metadata));\n}\n\nint\ntsk_individual_table_set_max_rows_increment(\n tsk_individual_table_t *self, tsk_size_t max_rows_increment)\n{\n self->max_rows_increment = max_rows_increment;\n return 0;\n}\n\nint\ntsk_individual_table_set_max_metadata_length_increment(\n tsk_individual_table_t *self, tsk_size_t max_metadata_length_increment)\n{\n self->max_metadata_length_increment = (tsk_size_t) max_metadata_length_increment;\n return 0;\n}\n\nint\ntsk_individual_table_set_max_location_length_increment(\n tsk_individual_table_t *self, tsk_size_t max_location_length_increment)\n{\n self->max_location_length_increment = (tsk_size_t) max_location_length_increment;\n return 0;\n}\n\nint\ntsk_individual_table_set_max_parents_length_increment(\n tsk_individual_table_t *self, tsk_size_t max_parents_length_increment)\n{\n self->max_parents_length_increment = (tsk_size_t) max_parents_length_increment;\n return 0;\n}\n\nint\ntsk_individual_table_init(tsk_individual_table_t *self, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n\n tsk_memset(self, 0, sizeof(tsk_individual_table_t));\n /* Allocate space for one row initially, ensuring we always have valid pointers\n * even if the table is empty */\n self->max_rows_increment = 1;\n self->max_location_length_increment = 1;\n self->max_parents_length_increment = 1;\n self->max_metadata_length_increment = 1;\n ret = tsk_individual_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_individual_table_expand_location(self, 1);\n if (ret != 0) {\n goto out;\n }\n self->location_offset[0] = 0;\n ret = tsk_individual_table_expand_parents(self, 1);\n if (ret != 0) {\n goto out;\n }\n self->parents_offset[0] = 0;\n ret = tsk_individual_table_expand_metadata(self, 1);\n if (ret != 0) {\n goto out;\n }\n self->metadata_offset[0] = 0;\n self->max_rows_increment = 0;\n self->max_location_length_increment = 0;\n self->max_parents_length_increment = 0;\n self->max_metadata_length_increment = 0;\n tsk_individual_table_set_metadata_schema(self, NULL, 0);\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_individual_table_copy(const tsk_individual_table_t *self,\n tsk_individual_table_t *dest, tsk_flags_t options)\n{\n int ret = 0;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_individual_table_init(dest, 0);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_individual_table_set_columns(dest, self->num_rows, self->flags,\n self->location, self->location_offset, self->parents, self->parents_offset,\n self->metadata, self->metadata_offset);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_individual_table_set_metadata_schema(\n dest, self->metadata_schema, self->metadata_schema_length);\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_individual_table_set_columns(tsk_individual_table_t *self, tsk_size_t num_rows,\n const tsk_flags_t *flags, const double *location, const tsk_size_t *location_offset,\n const tsk_id_t *parents, const tsk_size_t *parents_offset, const char *metadata,\n const tsk_size_t *metadata_offset)\n{\n int ret;\n\n ret = tsk_individual_table_clear(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_individual_table_append_columns(self, num_rows, flags, location,\n location_offset, parents, parents_offset, metadata, metadata_offset);\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_individual_table_takeset_columns(tsk_individual_table_t *self, tsk_size_t num_rows,\n tsk_flags_t *flags, double *location, tsk_size_t *location_offset, tsk_id_t *parents,\n tsk_size_t *parents_offset, char *metadata, tsk_size_t *metadata_offset)\n{\n int ret = 0;\n\n /* We need to check all the inputs before we start freeing or taking memory */\n ret = check_ragged_column(num_rows, location, location_offset);\n if (ret != 0) {\n goto out;\n }\n ret = check_ragged_column(num_rows, parents, parents_offset);\n if (ret != 0) {\n goto out;\n }\n ret = check_ragged_column(num_rows, metadata, metadata_offset);\n if (ret != 0) {\n goto out;\n }\n\n tsk_individual_table_free_columns(self);\n self->num_rows = num_rows;\n self->max_rows = num_rows;\n\n if (flags == NULL) {\n /* Flags defaults to all zeros if not specified. The column is often\n * unused so this is a worthwhile optimisation. */\n self->flags = tsk_calloc(num_rows, sizeof(*self->flags));\n if (self->flags == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n } else {\n self->flags = flags;\n }\n\n ret = takeset_ragged_column(num_rows, location, location_offset,\n (void *) &self->location, &self->location_offset, &self->location_length);\n if (ret != 0) {\n goto out;\n }\n ret = takeset_ragged_column(num_rows, parents, parents_offset,\n (void *) &self->parents, &self->parents_offset, &self->parents_length);\n if (ret != 0) {\n goto out;\n }\n ret = takeset_ragged_column(num_rows, metadata, metadata_offset,\n (void *) &self->metadata, &self->metadata_offset, &self->metadata_length);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nint\ntsk_individual_table_append_columns(tsk_individual_table_t *self, tsk_size_t num_rows,\n const tsk_flags_t *flags, const double *location, const tsk_size_t *location_offset,\n const tsk_id_t *parents, const tsk_size_t *parents_offset, const char *metadata,\n const tsk_size_t *metadata_offset)\n{\n int ret;\n tsk_size_t j, metadata_length, location_length, parents_length;\n\n if (flags == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if ((location == NULL) != (location_offset == NULL)) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if ((parents == NULL) != (parents_offset == NULL)) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if ((metadata == NULL) != (metadata_offset == NULL)) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n ret = tsk_individual_table_expand_main_columns(self, (tsk_size_t) num_rows);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->flags + self->num_rows, flags, num_rows * sizeof(tsk_flags_t));\n if (location == NULL) {\n for (j = 0; j < num_rows; j++) {\n self->location_offset[self->num_rows + j + 1]\n = (tsk_size_t) self->location_length;\n }\n } else {\n ret = check_offsets(num_rows, location_offset, 0, false);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n self->location_offset[self->num_rows + j]\n = (tsk_size_t) self->location_length + location_offset[j];\n }\n location_length = location_offset[num_rows];\n ret = tsk_individual_table_expand_location(self, location_length);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->location + self->location_length, location,\n location_length * sizeof(double));\n self->location_length += location_length;\n }\n if (parents == NULL) {\n for (j = 0; j < num_rows; j++) {\n self->parents_offset[self->num_rows + j + 1]\n = (tsk_size_t) self->parents_length;\n }\n } else {\n ret = check_offsets(num_rows, parents_offset, 0, false);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n self->parents_offset[self->num_rows + j]\n = (tsk_size_t) self->parents_length + parents_offset[j];\n }\n parents_length = parents_offset[num_rows];\n ret = tsk_individual_table_expand_parents(self, parents_length);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->parents + self->parents_length, parents,\n parents_length * sizeof(tsk_id_t));\n self->parents_length += parents_length;\n }\n if (metadata == NULL) {\n for (j = 0; j < num_rows; j++) {\n self->metadata_offset[self->num_rows + j + 1]\n = (tsk_size_t) self->metadata_length;\n }\n } else {\n ret = check_offsets(num_rows, metadata_offset, 0, false);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n self->metadata_offset[self->num_rows + j]\n = (tsk_size_t) self->metadata_length + metadata_offset[j];\n }\n metadata_length = metadata_offset[num_rows];\n ret = tsk_individual_table_expand_metadata(self, metadata_length);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->metadata + self->metadata_length, metadata,\n metadata_length * sizeof(char));\n self->metadata_length += metadata_length;\n }\n self->num_rows += (tsk_size_t) num_rows;\n self->location_offset[self->num_rows] = self->location_length;\n self->parents_offset[self->num_rows] = self->parents_length;\n self->metadata_offset[self->num_rows] = self->metadata_length;\nout:\n return ret;\n}\n\nstatic tsk_id_t\ntsk_individual_table_add_row_internal(tsk_individual_table_t *self, tsk_flags_t flags,\n const double *location, tsk_size_t location_length, const tsk_id_t *parents,\n const tsk_size_t parents_length, const char *metadata, tsk_size_t metadata_length)\n{\n tsk_bug_assert(self->num_rows < self->max_rows);\n tsk_bug_assert(self->parents_length + parents_length <= self->max_parents_length);\n tsk_bug_assert(self->metadata_length + metadata_length <= self->max_metadata_length);\n tsk_bug_assert(self->location_length + location_length <= self->max_location_length);\n self->flags[self->num_rows] = flags;\n tsk_memmove(self->location + self->location_length, location,\n location_length * sizeof(*self->location));\n self->location_offset[self->num_rows + 1] = self->location_length + location_length;\n self->location_length += location_length;\n tsk_memmove(self->parents + self->parents_length, parents,\n parents_length * sizeof(*self->parents));\n self->parents_offset[self->num_rows + 1] = self->parents_length + parents_length;\n self->parents_length += parents_length;\n tsk_memmove(self->metadata + self->metadata_length, metadata,\n metadata_length * sizeof(*self->metadata));\n self->metadata_offset[self->num_rows + 1] = self->metadata_length + metadata_length;\n self->metadata_length += metadata_length;\n self->num_rows++;\n return (tsk_id_t) self->num_rows - 1;\n}\n\ntsk_id_t\ntsk_individual_table_add_row(tsk_individual_table_t *self, tsk_flags_t flags,\n const double *location, tsk_size_t location_length, const tsk_id_t *parents,\n tsk_size_t parents_length, const char *metadata, tsk_size_t metadata_length)\n{\n tsk_id_t ret = 0;\n\n ret = tsk_individual_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_individual_table_expand_location(self, location_length);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_individual_table_expand_parents(self, parents_length);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_individual_table_expand_metadata(self, metadata_length);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_individual_table_add_row_internal(self, flags, location, location_length,\n parents, parents_length, metadata, metadata_length);\nout:\n return ret;\n}\n\nstatic int\ntsk_individual_table_update_row_rewrite(tsk_individual_table_t *self, tsk_id_t index,\n tsk_flags_t flags, const double *location, tsk_size_t location_length,\n const tsk_id_t *parents, tsk_size_t parents_length, const char *metadata,\n tsk_size_t metadata_length)\n{\n int ret = 0;\n tsk_id_t j, ret_id;\n tsk_individual_table_t copy;\n tsk_size_t num_rows;\n tsk_id_t *rows = NULL;\n\n ret = tsk_individual_table_copy(self, ©, 0);\n if (ret != 0) {\n goto out;\n }\n rows = tsk_malloc(self->num_rows * sizeof(*rows));\n if (rows == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n ret = tsk_individual_table_truncate(self, (tsk_size_t) index);\n tsk_bug_assert(ret == 0);\n ret_id = tsk_individual_table_add_row(self, flags, location, location_length,\n parents, parents_length, metadata, metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n num_rows = 0;\n for (j = index + 1; j < (tsk_id_t) copy.num_rows; j++) {\n rows[num_rows] = j;\n num_rows++;\n }\n ret = tsk_individual_table_extend(self, ©, num_rows, rows, 0);\n if (ret != 0) {\n goto out;\n }\nout:\n tsk_individual_table_free(©);\n tsk_safe_free(rows);\n return ret;\n}\n\nint\ntsk_individual_table_update_row(tsk_individual_table_t *self, tsk_id_t index,\n tsk_flags_t flags, const double *location, tsk_size_t location_length,\n const tsk_id_t *parents, tsk_size_t parents_length, const char *metadata,\n tsk_size_t metadata_length)\n{\n int ret = 0;\n tsk_individual_t current_row;\n\n ret = tsk_individual_table_get_row(self, index, ¤t_row);\n if (ret != 0) {\n goto out;\n }\n if (current_row.location_length == location_length\n && current_row.parents_length == parents_length\n && current_row.metadata_length == metadata_length) {\n self->flags[index] = flags;\n /* Note: important to use tsk_memmove here as we may be provided pointers\n * to the column memory as input via get_row */\n tsk_memmove(&self->location[self->location_offset[index]], location,\n location_length * sizeof(*location));\n tsk_memmove(&self->parents[self->parents_offset[index]], parents,\n parents_length * sizeof(*parents));\n tsk_memmove(&self->metadata[self->metadata_offset[index]], metadata,\n metadata_length * sizeof(*metadata));\n } else {\n ret = tsk_individual_table_update_row_rewrite(self, index, flags, location,\n location_length, parents, parents_length, metadata, metadata_length);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nint\ntsk_individual_table_clear(tsk_individual_table_t *self)\n{\n return tsk_individual_table_truncate(self, 0);\n}\n\nint\ntsk_individual_table_truncate(tsk_individual_table_t *self, tsk_size_t num_rows)\n{\n int ret = 0;\n\n if (num_rows > self->num_rows) {\n ret = tsk_trace_error(TSK_ERR_BAD_TABLE_POSITION);\n goto out;\n }\n self->num_rows = num_rows;\n self->location_length = self->location_offset[num_rows];\n self->parents_length = self->parents_offset[num_rows];\n self->metadata_length = self->metadata_offset[num_rows];\nout:\n return ret;\n}\n\nint\ntsk_individual_table_extend(tsk_individual_table_t *self,\n const tsk_individual_table_t *other, tsk_size_t num_rows,\n const tsk_id_t *row_indexes, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_individual_t individual;\n\n if (self == other) {\n ret = tsk_trace_error(TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n goto out;\n }\n\n /* We know how much to expand the non-ragged columns, so do it ahead of time */\n ret = tsk_individual_table_expand_main_columns(self, num_rows);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n ret = tsk_individual_table_get_row(\n other, row_indexes == NULL ? (tsk_id_t) j : row_indexes[j], &individual);\n if (ret != 0) {\n goto out;\n }\n ret_id = tsk_individual_table_add_row(self, individual.flags,\n individual.location, individual.location_length, individual.parents,\n individual.parents_length, individual.metadata, individual.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nvoid\ntsk_individual_table_print_state(const tsk_individual_table_t *self, FILE *out)\n{\n tsk_size_t j, k;\n\n fprintf(out, \"\\n\" TABLE_SEP);\n fprintf(out, \"tsk_individual_tbl: %p:\\n\", (const void *) self);\n fprintf(out, \"num_rows = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->num_rows, (long long) self->max_rows,\n (long long) self->max_rows_increment);\n fprintf(out, \"metadata_length = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->metadata_length, (long long) self->max_metadata_length,\n (long long) self->max_metadata_length_increment);\n fprintf(out, TABLE_SEP);\n /* We duplicate the dump_text code here because we want to output\n * the offset columns. */\n write_metadata_schema_header(\n out, self->metadata_schema, self->metadata_schema_length);\n fprintf(out, \"id\\tflags\\tlocation_offset\\tlocation\\t\");\n fprintf(out, \"parents_offset\\tparents\\t\");\n fprintf(out, \"metadata_offset\\tmetadata\\n\");\n for (j = 0; j < self->num_rows; j++) {\n fprintf(out, \"%lld\\t%lld\\t\", (long long) j, (long long) self->flags[j]);\n fprintf(out, \"%lld\\t\", (long long) self->location_offset[j]);\n for (k = self->location_offset[j]; k < self->location_offset[j + 1]; k++) {\n fprintf(out, \"%f\", self->location[k]);\n if (k + 1 < self->location_offset[j + 1]) {\n fprintf(out, \",\");\n }\n }\n fprintf(out, \"\\t\");\n fprintf(out, \"%lld\\t\", (long long) self->parents_offset[j]);\n for (k = self->parents_offset[j]; k < self->parents_offset[j + 1]; k++) {\n fprintf(out, \"%lld\", (long long) self->parents[k]);\n if (k + 1 < self->parents_offset[j + 1]) {\n fprintf(out, \",\");\n }\n }\n fprintf(out, \"\\t\");\n fprintf(out, \"%lld\\t\", (long long) self->metadata_offset[j]);\n for (k = self->metadata_offset[j]; k < self->metadata_offset[j + 1]; k++) {\n fprintf(out, \"%c\", self->metadata[k]);\n }\n fprintf(out, \"\\n\");\n }\n}\n\nstatic inline void\ntsk_individual_table_get_row_unsafe(\n const tsk_individual_table_t *self, tsk_id_t index, tsk_individual_t *row)\n{\n row->id = (tsk_id_t) index;\n row->flags = self->flags[index];\n row->location_length\n = self->location_offset[index + 1] - self->location_offset[index];\n row->location = self->location + self->location_offset[index];\n row->parents_length = self->parents_offset[index + 1] - self->parents_offset[index];\n row->parents = self->parents + self->parents_offset[index];\n row->metadata_length\n = self->metadata_offset[index + 1] - self->metadata_offset[index];\n row->metadata = self->metadata + self->metadata_offset[index];\n /* Also have referencing individuals here. Should this be a different struct?\n * See also site. */\n row->nodes_length = 0;\n row->nodes = NULL;\n}\n\nint\ntsk_individual_table_get_row(\n const tsk_individual_table_t *self, tsk_id_t index, tsk_individual_t *row)\n{\n int ret = 0;\n\n if (index < 0 || index >= (tsk_id_t) self->num_rows) {\n ret = tsk_trace_error(TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n goto out;\n }\n tsk_individual_table_get_row_unsafe(self, index, row);\nout:\n return ret;\n}\n\nint\ntsk_individual_table_set_metadata_schema(tsk_individual_table_t *self,\n const char *metadata_schema, tsk_size_t metadata_schema_length)\n{\n return replace_string(&self->metadata_schema, &self->metadata_schema_length,\n metadata_schema, metadata_schema_length);\n}\n\nint\ntsk_individual_table_dump_text(const tsk_individual_table_t *self, FILE *out)\n{\n int ret = TSK_ERR_IO;\n tsk_size_t j, k;\n tsk_size_t metadata_len;\n int err;\n\n err = write_metadata_schema_header(\n out, self->metadata_schema, self->metadata_schema_length);\n if (err < 0) {\n goto out;\n }\n err = fprintf(out, \"id\\tflags\\tlocation\\tparents\\tmetadata\\n\");\n if (err < 0) {\n goto out;\n }\n for (j = 0; j < self->num_rows; j++) {\n metadata_len = self->metadata_offset[j + 1] - self->metadata_offset[j];\n err = fprintf(out, \"%lld\\t%lld\\t\", (long long) j, (long long) self->flags[j]);\n if (err < 0) {\n goto out;\n }\n for (k = self->location_offset[j]; k < self->location_offset[j + 1]; k++) {\n err = fprintf(out, \"%.*g\", TSK_DBL_DECIMAL_DIG, self->location[k]);\n if (err < 0) {\n goto out;\n }\n if (k + 1 < self->location_offset[j + 1]) {\n err = fprintf(out, \",\");\n if (err < 0) {\n goto out;\n }\n }\n }\n err = fprintf(out, \"\\t\");\n if (err < 0) {\n goto out;\n }\n for (k = self->parents_offset[j]; k < self->parents_offset[j + 1]; k++) {\n err = fprintf(out, \"%lld\", (long long) self->parents[k]);\n if (err < 0) {\n goto out;\n }\n if (k + 1 < self->parents_offset[j + 1]) {\n err = fprintf(out, \",\");\n if (err < 0) {\n goto out;\n }\n }\n }\n err = fprintf(out, \"\\t%.*s\\n\", (int) metadata_len,\n self->metadata + self->metadata_offset[j]);\n if (err < 0) {\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nbool\ntsk_individual_table_equals(const tsk_individual_table_t *self,\n const tsk_individual_table_t *other, tsk_flags_t options)\n{\n bool ret\n = self->num_rows == other->num_rows\n && tsk_memcmp(self->flags, other->flags, self->num_rows * sizeof(tsk_flags_t))\n == 0\n && tsk_memcmp(self->location_offset, other->location_offset,\n (self->num_rows + 1) * sizeof(tsk_size_t))\n == 0\n && tsk_memcmp(\n self->location, other->location, self->location_length * sizeof(double))\n == 0\n && tsk_memcmp(self->parents_offset, other->parents_offset,\n (self->num_rows + 1) * sizeof(tsk_size_t))\n == 0\n && tsk_memcmp(\n self->parents, other->parents, self->parents_length * sizeof(tsk_id_t))\n == 0;\n\n if (!(options & TSK_CMP_IGNORE_METADATA)) {\n ret = ret && self->metadata_length == other->metadata_length\n && self->metadata_schema_length == other->metadata_schema_length\n && tsk_memcmp(self->metadata_offset, other->metadata_offset,\n (self->num_rows + 1) * sizeof(tsk_size_t))\n == 0\n && tsk_memcmp(self->metadata, other->metadata,\n self->metadata_length * sizeof(char))\n == 0\n && tsk_memcmp(self->metadata_schema, other->metadata_schema,\n self->metadata_schema_length * sizeof(char))\n == 0;\n }\n return ret;\n}\n\nint\ntsk_individual_table_keep_rows(tsk_individual_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t TSK_UNUSED(options), tsk_id_t *ret_id_map)\n{\n int ret = 0;\n const tsk_size_t current_num_rows = self->num_rows;\n tsk_size_t j, k, remaining_rows;\n tsk_id_t pk;\n tsk_id_t *id_map = ret_id_map;\n tsk_id_t *restrict parents = self->parents;\n tsk_size_t *restrict parents_offset = self->parents_offset;\n\n if (ret_id_map == NULL) {\n id_map = tsk_malloc(current_num_rows * sizeof(*id_map));\n if (id_map == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n }\n\n keep_mask_to_id_map(current_num_rows, keep, id_map);\n\n /* See notes in tsk_mutation_table_keep_rows for possibilities\n * on making this more flexible */\n for (j = 0; j < current_num_rows; j++) {\n if (keep[j]) {\n for (k = parents_offset[j]; k < parents_offset[j + 1]; k++) {\n pk = parents[k];\n if (pk != TSK_NULL) {\n if (pk < 0 || pk >= (tsk_id_t) current_num_rows) {\n ret = tsk_trace_error(TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n ;\n goto out;\n }\n if (id_map[pk] == TSK_NULL) {\n ret = tsk_trace_error(TSK_ERR_KEEP_ROWS_MAP_TO_DELETED);\n goto out;\n }\n }\n }\n }\n }\n\n remaining_rows = subset_flags_column(self->flags, current_num_rows, keep);\n self->parents_length = subset_remap_ragged_id_column(\n self->parents, self->parents_offset, current_num_rows, keep, id_map);\n self->location_length = subset_ragged_double_column(\n self->location, self->location_offset, current_num_rows, keep);\n if (self->metadata_length > 0) {\n /* Implementation note: we special case metadata here because\n * it'll make the common-case of no metadata a bit faster, and\n * to also potentially support more general use of the\n * TSK_TABLE_NO_METADATA option. This is done for all the tables\n * but only commented on here. */\n self->metadata_length = subset_ragged_char_column(\n self->metadata, self->metadata_offset, current_num_rows, keep);\n }\n self->num_rows = remaining_rows;\nout:\n if (ret_id_map == NULL) {\n tsk_safe_free(id_map);\n }\n return ret;\n}\n\nstatic int\ntsk_individual_table_dump(\n const tsk_individual_table_t *self, kastore_t *store, tsk_flags_t options)\n{\n const write_table_col_t write_cols[] = {\n { \"individuals/flags\", (void *) self->flags, self->num_rows,\n TSK_FLAGS_STORAGE_TYPE },\n { \"individuals/metadata_schema\", (void *) self->metadata_schema,\n self->metadata_schema_length, KAS_UINT8 },\n { .name = NULL },\n };\n const write_table_ragged_col_t ragged_cols[] = {\n { \"individuals/location\", (void *) self->location, self->location_length,\n KAS_FLOAT64, self->location_offset, self->num_rows },\n { \"individuals/parents\", (void *) self->parents, self->parents_length,\n TSK_ID_STORAGE_TYPE, self->parents_offset, self->num_rows },\n { \"individuals/metadata\", (void *) self->metadata, self->metadata_length,\n KAS_UINT8, self->metadata_offset, self->num_rows },\n { .name = NULL },\n };\n\n return write_table(store, write_cols, ragged_cols, options);\n}\n\nstatic int\ntsk_individual_table_load(tsk_individual_table_t *self, kastore_t *store)\n{\n int ret = 0;\n tsk_flags_t *flags = NULL;\n double *location = NULL;\n tsk_size_t *location_offset = NULL;\n tsk_id_t *parents = NULL;\n tsk_size_t *parents_offset = NULL;\n char *metadata = NULL;\n tsk_size_t *metadata_offset = NULL;\n char *metadata_schema = NULL;\n tsk_size_t num_rows, location_length, parents_length, metadata_length,\n metadata_schema_length;\n\n read_table_col_t cols[] = {\n { \"individuals/flags\", (void **) &flags, TSK_FLAGS_STORAGE_TYPE, 0 },\n { .name = NULL },\n };\n read_table_ragged_col_t ragged_cols[] = {\n { \"individuals/location\", (void **) &location, &location_length, KAS_FLOAT64,\n &location_offset, 0 },\n { \"individuals/parents\", (void **) &parents, &parents_length,\n TSK_ID_STORAGE_TYPE, &parents_offset, TSK_COL_OPTIONAL },\n { \"individuals/metadata\", (void **) &metadata, &metadata_length, KAS_UINT8,\n &metadata_offset, 0 },\n { .name = NULL },\n };\n read_table_property_t properties[] = {\n { \"individuals/metadata_schema\", (void **) &metadata_schema,\n &metadata_schema_length, KAS_UINT8, TSK_COL_OPTIONAL },\n { .name = NULL },\n };\n\n ret = read_table(store, &num_rows, cols, ragged_cols, properties, 0);\n if (ret != 0) {\n goto out;\n }\n if (metadata_schema != NULL) {\n ret = tsk_individual_table_set_metadata_schema(\n self, metadata_schema, metadata_schema_length);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_individual_table_takeset_columns(self, num_rows, flags, location,\n location_offset, parents, parents_offset, metadata, metadata_offset);\n if (ret != 0) {\n goto out;\n }\n flags = NULL;\n location = NULL;\n location_offset = NULL;\n parents = NULL;\n parents_offset = NULL;\n metadata = NULL;\n metadata_offset = NULL;\n\nout:\n free_read_table_mem(cols, ragged_cols, properties);\n return ret;\n}\n\n/*************************\n * node table\n *************************/\n\nstatic void\ntsk_node_table_free_columns(tsk_node_table_t *self)\n{\n tsk_safe_free(self->flags);\n tsk_safe_free(self->time);\n tsk_safe_free(self->population);\n tsk_safe_free(self->individual);\n tsk_safe_free(self->metadata);\n tsk_safe_free(self->metadata_offset);\n}\n\nint\ntsk_node_table_free(tsk_node_table_t *self)\n{\n tsk_node_table_free_columns(self);\n tsk_safe_free(self->metadata_schema);\n return 0;\n}\n\nstatic int\ntsk_node_table_expand_main_columns(tsk_node_table_t *self, tsk_size_t additional_rows)\n{\n int ret = 0;\n tsk_size_t new_max_rows;\n\n ret = calculate_max_rows(self->num_rows, self->max_rows, self->max_rows_increment,\n additional_rows, &new_max_rows);\n if (ret != 0) {\n goto out;\n }\n\n if (new_max_rows > self->max_rows) {\n ret = expand_column((void **) &self->flags, new_max_rows, sizeof(tsk_flags_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column((void **) &self->time, new_max_rows, sizeof(double));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column((void **) &self->population, new_max_rows, sizeof(tsk_id_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column((void **) &self->individual, new_max_rows, sizeof(tsk_id_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column(\n (void **) &self->metadata_offset, new_max_rows + 1, sizeof(tsk_size_t));\n if (ret != 0) {\n goto out;\n }\n self->max_rows = new_max_rows;\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_node_table_expand_metadata(tsk_node_table_t *self, tsk_size_t additional_length)\n{\n return expand_ragged_column(self->metadata_length, additional_length,\n self->max_metadata_length_increment, &self->max_metadata_length,\n (void **) &self->metadata, sizeof(*self->metadata));\n}\n\nint\ntsk_node_table_set_max_rows_increment(\n tsk_node_table_t *self, tsk_size_t max_rows_increment)\n{\n self->max_rows_increment = max_rows_increment;\n return 0;\n}\n\nint\ntsk_node_table_set_max_metadata_length_increment(\n tsk_node_table_t *self, tsk_size_t max_metadata_length_increment)\n{\n self->max_metadata_length_increment = max_metadata_length_increment;\n return 0;\n}\n\nint\ntsk_node_table_init(tsk_node_table_t *self, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n\n tsk_memset(self, 0, sizeof(tsk_node_table_t));\n /* Allocate space for one row initially, ensuring we always have valid pointers\n * even if the table is empty */\n self->max_rows_increment = 1;\n self->max_metadata_length_increment = 1;\n ret = tsk_node_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_node_table_expand_metadata(self, 1);\n if (ret != 0) {\n goto out;\n }\n self->metadata_offset[0] = 0;\n self->max_rows_increment = 0;\n self->max_metadata_length_increment = 0;\n tsk_node_table_set_metadata_schema(self, NULL, 0);\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_node_table_copy(\n const tsk_node_table_t *self, tsk_node_table_t *dest, tsk_flags_t options)\n{\n int ret = 0;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_node_table_init(dest, 0);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_node_table_set_columns(dest, self->num_rows, self->flags, self->time,\n self->population, self->individual, self->metadata, self->metadata_offset);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_node_table_set_metadata_schema(\n dest, self->metadata_schema, self->metadata_schema_length);\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_node_table_set_columns(tsk_node_table_t *self, tsk_size_t num_rows,\n const tsk_flags_t *flags, const double *time, const tsk_id_t *population,\n const tsk_id_t *individual, const char *metadata, const tsk_size_t *metadata_offset)\n{\n int ret;\n\n ret = tsk_node_table_clear(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_node_table_append_columns(\n self, num_rows, flags, time, population, individual, metadata, metadata_offset);\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_node_table_takeset_columns(tsk_node_table_t *self, tsk_size_t num_rows,\n tsk_flags_t *flags, double *time, tsk_id_t *population, tsk_id_t *individual,\n char *metadata, tsk_size_t *metadata_offset)\n{\n int ret = 0;\n\n /* We need to check all the inputs before we start freeing or taking memory */\n if (flags == NULL || time == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n ret = check_ragged_column(num_rows, metadata, metadata_offset);\n if (ret != 0) {\n goto out;\n }\n\n tsk_node_table_free_columns(self);\n self->num_rows = num_rows;\n self->max_rows = num_rows;\n self->flags = flags;\n self->time = time;\n\n ret = takeset_optional_id_column(num_rows, population, &self->population);\n if (ret != 0) {\n goto out;\n }\n ret = takeset_optional_id_column(num_rows, individual, &self->individual);\n if (ret != 0) {\n goto out;\n }\n\n ret = takeset_ragged_column(num_rows, metadata, metadata_offset,\n (void *) &self->metadata, &self->metadata_offset, &self->metadata_length);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nint\ntsk_node_table_append_columns(tsk_node_table_t *self, tsk_size_t num_rows,\n const tsk_flags_t *flags, const double *time, const tsk_id_t *population,\n const tsk_id_t *individual, const char *metadata, const tsk_size_t *metadata_offset)\n{\n int ret;\n tsk_size_t j, metadata_length;\n\n if (flags == NULL || time == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if ((metadata == NULL) != (metadata_offset == NULL)) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n ret = tsk_node_table_expand_main_columns(self, num_rows);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->time + self->num_rows, time, num_rows * sizeof(double));\n tsk_memcpy(self->flags + self->num_rows, flags, num_rows * sizeof(tsk_flags_t));\n if (metadata == NULL) {\n for (j = 0; j < num_rows; j++) {\n self->metadata_offset[self->num_rows + j + 1] = self->metadata_length;\n }\n } else {\n ret = check_offsets(num_rows, metadata_offset, 0, false);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n self->metadata_offset[self->num_rows + j]\n = (tsk_size_t) self->metadata_length + metadata_offset[j];\n }\n metadata_length = metadata_offset[num_rows];\n ret = tsk_node_table_expand_metadata(self, metadata_length);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->metadata + self->metadata_length, metadata,\n metadata_length * sizeof(char));\n self->metadata_length += metadata_length;\n }\n if (population == NULL) {\n /* Set population to NULL_POPULATION (-1) if not specified */\n tsk_memset(self->population + self->num_rows, 0xff, num_rows * sizeof(tsk_id_t));\n } else {\n tsk_memcpy(\n self->population + self->num_rows, population, num_rows * sizeof(tsk_id_t));\n }\n if (individual == NULL) {\n /* Set individual to NULL_INDIVIDUAL (-1) if not specified */\n tsk_memset(self->individual + self->num_rows, 0xff, num_rows * sizeof(tsk_id_t));\n } else {\n tsk_memcpy(\n self->individual + self->num_rows, individual, num_rows * sizeof(tsk_id_t));\n }\n self->num_rows += (tsk_size_t) num_rows;\n self->metadata_offset[self->num_rows] = self->metadata_length;\nout:\n return ret;\n}\n\nstatic tsk_id_t\ntsk_node_table_add_row_internal(tsk_node_table_t *self, tsk_flags_t flags, double time,\n tsk_id_t population, tsk_id_t individual, const char *metadata,\n tsk_size_t metadata_length)\n{\n tsk_bug_assert(self->num_rows < self->max_rows);\n tsk_bug_assert(self->metadata_length + metadata_length <= self->max_metadata_length);\n tsk_memmove(self->metadata + self->metadata_length, metadata, metadata_length);\n self->flags[self->num_rows] = flags;\n self->time[self->num_rows] = time;\n self->population[self->num_rows] = population;\n self->individual[self->num_rows] = individual;\n self->metadata_offset[self->num_rows + 1] = self->metadata_length + metadata_length;\n self->metadata_length += metadata_length;\n self->num_rows++;\n return (tsk_id_t) self->num_rows - 1;\n}\n\ntsk_id_t\ntsk_node_table_add_row(tsk_node_table_t *self, tsk_flags_t flags, double time,\n tsk_id_t population, tsk_id_t individual, const char *metadata,\n tsk_size_t metadata_length)\n{\n tsk_id_t ret = 0;\n\n ret = tsk_node_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_node_table_expand_metadata(self, metadata_length);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_node_table_add_row_internal(\n self, flags, time, population, individual, metadata, metadata_length);\nout:\n return ret;\n}\n\nstatic int\ntsk_node_table_update_row_rewrite(tsk_node_table_t *self, tsk_id_t index,\n tsk_flags_t flags, double time, tsk_id_t population, tsk_id_t individual,\n const char *metadata, tsk_size_t metadata_length)\n{\n int ret = 0;\n tsk_id_t j, ret_id;\n tsk_node_table_t copy;\n tsk_size_t num_rows;\n tsk_id_t *rows = NULL;\n\n ret = tsk_node_table_copy(self, ©, 0);\n if (ret != 0) {\n goto out;\n }\n rows = tsk_malloc(self->num_rows * sizeof(*rows));\n if (rows == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n ret = tsk_node_table_truncate(self, (tsk_size_t) index);\n tsk_bug_assert(ret == 0);\n ret_id = tsk_node_table_add_row(\n self, flags, time, population, individual, metadata, metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n num_rows = 0;\n for (j = index + 1; j < (tsk_id_t) copy.num_rows; j++) {\n rows[num_rows] = j;\n num_rows++;\n }\n ret = tsk_node_table_extend(self, ©, num_rows, rows, 0);\n if (ret != 0) {\n goto out;\n }\nout:\n tsk_node_table_free(©);\n tsk_safe_free(rows);\n return ret;\n}\n\nint\ntsk_node_table_update_row(tsk_node_table_t *self, tsk_id_t index, tsk_flags_t flags,\n double time, tsk_id_t population, tsk_id_t individual, const char *metadata,\n tsk_size_t metadata_length)\n{\n int ret = 0;\n tsk_node_t current_row;\n\n ret = tsk_node_table_get_row(self, index, ¤t_row);\n if (ret != 0) {\n goto out;\n }\n if (current_row.metadata_length == metadata_length) {\n self->flags[index] = flags;\n self->time[index] = time;\n self->population[index] = population;\n self->individual[index] = individual;\n /* Note: important to use tsk_memmove here as we may be provided pointers\n * to the column memory as input via get_row */\n tsk_memmove(&self->metadata[self->metadata_offset[index]], metadata,\n metadata_length * sizeof(*metadata));\n } else {\n ret = tsk_node_table_update_row_rewrite(\n self, index, flags, time, population, individual, metadata, metadata_length);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_node_table_clear(tsk_node_table_t *self)\n{\n return tsk_node_table_truncate(self, 0);\n}\n\nint\ntsk_node_table_truncate(tsk_node_table_t *self, tsk_size_t num_rows)\n{\n int ret = 0;\n\n if (num_rows > self->num_rows) {\n ret = tsk_trace_error(TSK_ERR_BAD_TABLE_POSITION);\n goto out;\n }\n self->num_rows = num_rows;\n self->metadata_length = self->metadata_offset[num_rows];\nout:\n return ret;\n}\n\nint\ntsk_node_table_extend(tsk_node_table_t *self, const tsk_node_table_t *other,\n tsk_size_t num_rows, const tsk_id_t *row_indexes, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_node_t node;\n\n if (self == other) {\n ret = tsk_trace_error(TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n goto out;\n }\n\n /* We know how much to expand the non-ragged columns, so do it ahead of time */\n ret = tsk_node_table_expand_main_columns(self, num_rows);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n ret = tsk_node_table_get_row(\n other, row_indexes == NULL ? (tsk_id_t) j : row_indexes[j], &node);\n if (ret != 0) {\n goto out;\n }\n ret_id = tsk_node_table_add_row(self, node.flags, node.time, node.population,\n node.individual, node.metadata, node.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nvoid\ntsk_node_table_print_state(const tsk_node_table_t *self, FILE *out)\n{\n tsk_size_t j, k;\n\n fprintf(out, \"\\n\" TABLE_SEP);\n fprintf(out, \"tsk_node_tbl: %p:\\n\", (const void *) self);\n fprintf(out, \"num_rows = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->num_rows, (long long) self->max_rows,\n (long long) self->max_rows_increment);\n fprintf(out, \"metadata_length = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->metadata_length, (long long) self->max_metadata_length,\n (long long) self->max_metadata_length_increment);\n fprintf(out, TABLE_SEP);\n /* We duplicate the dump_text code here for simplicity because we want to output\n * the flags column directly. */\n write_metadata_schema_header(\n out, self->metadata_schema, self->metadata_schema_length);\n fprintf(out, \"id\\tflags\\ttime\\tpopulation\\tindividual\\tmetadata_offset\\tmetadata\\n\");\n for (j = 0; j < self->num_rows; j++) {\n fprintf(out, \"%lld\\t%lld\\t%f\\t%lld\\t%lld\\t%lld\\t\", (long long) j,\n (long long) self->flags[j], self->time[j], (long long) self->population[j],\n (long long) self->individual[j], (long long) self->metadata_offset[j]);\n for (k = self->metadata_offset[j]; k < self->metadata_offset[j + 1]; k++) {\n fprintf(out, \"%c\", self->metadata[k]);\n }\n fprintf(out, \"\\n\");\n }\n tsk_bug_assert(self->metadata_offset[0] == 0);\n tsk_bug_assert(self->metadata_offset[self->num_rows] == self->metadata_length);\n}\n\nint\ntsk_node_table_set_metadata_schema(tsk_node_table_t *self, const char *metadata_schema,\n tsk_size_t metadata_schema_length)\n{\n return replace_string(&self->metadata_schema, &self->metadata_schema_length,\n metadata_schema, metadata_schema_length);\n}\n\nint\ntsk_node_table_dump_text(const tsk_node_table_t *self, FILE *out)\n{\n int ret = TSK_ERR_IO;\n tsk_size_t j;\n tsk_size_t metadata_len;\n int err;\n\n err = write_metadata_schema_header(\n out, self->metadata_schema, self->metadata_schema_length);\n if (err < 0) {\n goto out;\n }\n err = fprintf(out, \"id\\tis_sample\\ttime\\tpopulation\\tindividual\\tmetadata\\n\");\n if (err < 0) {\n goto out;\n }\n for (j = 0; j < self->num_rows; j++) {\n metadata_len = self->metadata_offset[j + 1] - self->metadata_offset[j];\n err = fprintf(out, \"%lld\\t%lld\\t%f\\t%lld\\t%lld\\t%.*s\\n\", (long long) j,\n (long long) (self->flags[j] & TSK_NODE_IS_SAMPLE), self->time[j],\n (long long) self->population[j], (long long) self->individual[j],\n (int) metadata_len, self->metadata + self->metadata_offset[j]);\n if (err < 0) {\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nbool\ntsk_node_table_equals(\n const tsk_node_table_t *self, const tsk_node_table_t *other, tsk_flags_t options)\n{\n bool ret\n = self->num_rows == other->num_rows\n && tsk_memcmp(self->time, other->time, self->num_rows * sizeof(double)) == 0\n && tsk_memcmp(self->flags, other->flags, self->num_rows * sizeof(tsk_flags_t))\n == 0\n && tsk_memcmp(\n self->population, other->population, self->num_rows * sizeof(tsk_id_t))\n == 0\n && tsk_memcmp(\n self->individual, other->individual, self->num_rows * sizeof(tsk_id_t))\n == 0;\n if (!(options & TSK_CMP_IGNORE_METADATA)) {\n ret = ret && self->metadata_length == other->metadata_length\n && self->metadata_schema_length == other->metadata_schema_length\n && tsk_memcmp(self->metadata_offset, other->metadata_offset,\n (self->num_rows + 1) * sizeof(tsk_size_t))\n == 0\n && tsk_memcmp(self->metadata, other->metadata,\n self->metadata_length * sizeof(char))\n == 0\n && tsk_memcmp(self->metadata_schema, other->metadata_schema,\n self->metadata_schema_length * sizeof(char))\n == 0;\n }\n return ret;\n}\n\nstatic inline void\ntsk_node_table_get_row_unsafe(\n const tsk_node_table_t *self, tsk_id_t index, tsk_node_t *row)\n{\n row->id = (tsk_id_t) index;\n row->flags = self->flags[index];\n row->time = self->time[index];\n row->population = self->population[index];\n row->individual = self->individual[index];\n row->metadata_length\n = self->metadata_offset[index + 1] - self->metadata_offset[index];\n row->metadata = self->metadata + self->metadata_offset[index];\n}\n\nint\ntsk_node_table_get_row(const tsk_node_table_t *self, tsk_id_t index, tsk_node_t *row)\n{\n int ret = 0;\n\n if (index < 0 || index >= (tsk_id_t) self->num_rows) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n tsk_node_table_get_row_unsafe(self, index, row);\nout:\n return ret;\n}\n\nint\ntsk_node_table_keep_rows(tsk_node_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t TSK_UNUSED(options), tsk_id_t *id_map)\n{\n int ret = 0;\n tsk_size_t remaining_rows;\n\n if (id_map != NULL) {\n keep_mask_to_id_map(self->num_rows, keep, id_map);\n }\n\n remaining_rows = subset_flags_column(self->flags, self->num_rows, keep);\n subset_double_column(self->time, self->num_rows, keep);\n subset_id_column(self->population, self->num_rows, keep);\n subset_id_column(self->individual, self->num_rows, keep);\n if (self->metadata_length > 0) {\n self->metadata_length = subset_ragged_char_column(\n self->metadata, self->metadata_offset, self->num_rows, keep);\n }\n self->num_rows = remaining_rows;\n return ret;\n}\n\nstatic int\ntsk_node_table_dump(const tsk_node_table_t *self, kastore_t *store, tsk_flags_t options)\n{\n const write_table_col_t cols[] = {\n { \"nodes/time\", (void *) self->time, self->num_rows, KAS_FLOAT64 },\n { \"nodes/flags\", (void *) self->flags, self->num_rows, TSK_FLAGS_STORAGE_TYPE },\n { \"nodes/population\", (void *) self->population, self->num_rows,\n TSK_ID_STORAGE_TYPE },\n { \"nodes/individual\", (void *) self->individual, self->num_rows,\n TSK_ID_STORAGE_TYPE },\n { \"nodes/metadata_schema\", (void *) self->metadata_schema,\n self->metadata_schema_length, KAS_UINT8 },\n { .name = NULL },\n };\n const write_table_ragged_col_t ragged_cols[] = {\n { \"nodes/metadata\", (void *) self->metadata, self->metadata_length, KAS_UINT8,\n self->metadata_offset, self->num_rows },\n { .name = NULL },\n };\n\n return write_table(store, cols, ragged_cols, options);\n}\n\nstatic int\ntsk_node_table_load(tsk_node_table_t *self, kastore_t *store)\n{\n int ret = 0;\n char *metadata_schema = NULL;\n double *time = NULL;\n tsk_flags_t *flags = NULL;\n tsk_id_t *population = NULL;\n tsk_id_t *individual = NULL;\n char *metadata = NULL;\n tsk_size_t *metadata_offset = NULL;\n tsk_size_t num_rows, metadata_length, metadata_schema_length;\n read_table_col_t cols[] = {\n { \"nodes/time\", (void **) &time, KAS_FLOAT64, 0 },\n { \"nodes/flags\", (void **) &flags, TSK_FLAGS_STORAGE_TYPE, 0 },\n { \"nodes/population\", (void **) &population, TSK_ID_STORAGE_TYPE, 0 },\n { \"nodes/individual\", (void **) &individual, TSK_ID_STORAGE_TYPE, 0 },\n { .name = NULL },\n };\n read_table_ragged_col_t ragged_cols[] = {\n { \"nodes/metadata\", (void **) &metadata, &metadata_length, KAS_UINT8,\n &metadata_offset, 0 },\n { .name = NULL },\n };\n read_table_property_t properties[] = {\n { \"nodes/metadata_schema\", (void **) &metadata_schema, &metadata_schema_length,\n KAS_UINT8, TSK_COL_OPTIONAL },\n { .name = NULL },\n };\n\n ret = read_table(store, &num_rows, cols, ragged_cols, properties, 0);\n if (ret != 0) {\n goto out;\n }\n if (metadata_schema != NULL) {\n ret = tsk_node_table_set_metadata_schema(\n self, metadata_schema, metadata_schema_length);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_node_table_takeset_columns(\n self, num_rows, flags, time, population, individual, metadata, metadata_offset);\n if (ret != 0) {\n goto out;\n }\n flags = NULL;\n time = NULL;\n population = NULL;\n individual = NULL;\n metadata = NULL;\n metadata_offset = NULL;\nout:\n free_read_table_mem(cols, ragged_cols, properties);\n return ret;\n}\n\n/*************************\n * edge table\n *************************/\n\nstatic void\ntsk_edge_table_free_columns(tsk_edge_table_t *self)\n{\n tsk_safe_free(self->left);\n tsk_safe_free(self->right);\n tsk_safe_free(self->parent);\n tsk_safe_free(self->child);\n tsk_safe_free(self->metadata);\n tsk_safe_free(self->metadata_offset);\n}\n\nint\ntsk_edge_table_free(tsk_edge_table_t *self)\n{\n tsk_edge_table_free_columns(self);\n tsk_safe_free(self->metadata_schema);\n return 0;\n}\n\nstatic int\ntsk_edge_table_has_metadata(const tsk_edge_table_t *self)\n{\n return !(self->options & TSK_TABLE_NO_METADATA);\n}\n\nstatic int\ntsk_edge_table_expand_main_columns(tsk_edge_table_t *self, tsk_size_t additional_rows)\n{\n int ret = 0;\n tsk_size_t new_max_rows;\n\n ret = calculate_max_rows(self->num_rows, self->max_rows, self->max_rows_increment,\n additional_rows, &new_max_rows);\n if (ret != 0) {\n goto out;\n }\n if ((self->num_rows + additional_rows) > self->max_rows) {\n ret = expand_column((void **) &self->left, new_max_rows, sizeof(double));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column((void **) &self->right, new_max_rows, sizeof(double));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column((void **) &self->parent, new_max_rows, sizeof(tsk_id_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column((void **) &self->child, new_max_rows, sizeof(tsk_id_t));\n if (ret != 0) {\n goto out;\n }\n if (tsk_edge_table_has_metadata(self)) {\n ret = expand_column(\n (void **) &self->metadata_offset, new_max_rows + 1, sizeof(tsk_size_t));\n if (ret != 0) {\n goto out;\n }\n }\n self->max_rows = new_max_rows;\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_edge_table_expand_metadata(tsk_edge_table_t *self, tsk_size_t additional_length)\n{\n return expand_ragged_column(self->metadata_length, additional_length,\n self->max_metadata_length_increment, &self->max_metadata_length,\n (void **) &self->metadata, sizeof(*self->metadata));\n}\n\nint\ntsk_edge_table_set_max_rows_increment(\n tsk_edge_table_t *self, tsk_size_t max_rows_increment)\n{\n self->max_rows_increment = max_rows_increment;\n return 0;\n}\n\nint\ntsk_edge_table_set_max_metadata_length_increment(\n tsk_edge_table_t *self, tsk_size_t max_metadata_length_increment)\n{\n self->max_metadata_length_increment = max_metadata_length_increment;\n return 0;\n}\n\nint\ntsk_edge_table_init(tsk_edge_table_t *self, tsk_flags_t options)\n{\n int ret = 0;\n\n tsk_memset(self, 0, sizeof(*self));\n self->options = options;\n\n /* Allocate space for one row initially, ensuring we always have valid\n * pointers even if the table is empty */\n self->max_rows_increment = 1;\n self->max_metadata_length_increment = 1;\n ret = tsk_edge_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n if (tsk_edge_table_has_metadata(self)) {\n ret = tsk_edge_table_expand_metadata(self, 1);\n if (ret != 0) {\n goto out;\n }\n self->metadata_offset[0] = 0;\n }\n self->max_rows_increment = 0;\n self->max_metadata_length_increment = 0;\n tsk_edge_table_set_metadata_schema(self, NULL, 0);\nout:\n return ret;\n}\n\ntsk_id_t\ntsk_edge_table_add_row(tsk_edge_table_t *self, double left, double right,\n tsk_id_t parent, tsk_id_t child, const char *metadata, tsk_size_t metadata_length)\n{\n tsk_id_t ret = 0;\n\n if (metadata_length > 0 && !tsk_edge_table_has_metadata(self)) {\n ret = tsk_trace_error(TSK_ERR_METADATA_DISABLED);\n goto out;\n }\n\n ret = tsk_edge_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n\n tsk_bug_assert(self->num_rows < self->max_rows);\n self->left[self->num_rows] = left;\n self->right[self->num_rows] = right;\n self->parent[self->num_rows] = parent;\n self->child[self->num_rows] = child;\n\n if (tsk_edge_table_has_metadata(self)) {\n ret = tsk_edge_table_expand_metadata(self, metadata_length);\n if (ret != 0) {\n goto out;\n }\n tsk_bug_assert(\n self->metadata_length + metadata_length <= self->max_metadata_length);\n tsk_memmove(self->metadata + self->metadata_length, metadata, metadata_length);\n self->metadata_offset[self->num_rows + 1]\n = self->metadata_length + metadata_length;\n self->metadata_length += metadata_length;\n }\n ret = (tsk_id_t) self->num_rows;\n self->num_rows++;\nout:\n return ret;\n}\n\nstatic int\ntsk_edge_table_update_row_rewrite(tsk_edge_table_t *self, tsk_id_t index, double left,\n double right, tsk_id_t parent, tsk_id_t child, const char *metadata,\n tsk_size_t metadata_length)\n{\n int ret = 0;\n tsk_id_t j, ret_id;\n tsk_edge_table_t copy;\n tsk_size_t num_rows;\n tsk_id_t *rows = NULL;\n\n ret = tsk_edge_table_copy(self, ©, 0);\n if (ret != 0) {\n goto out;\n }\n rows = tsk_malloc(self->num_rows * sizeof(*rows));\n if (rows == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n ret = tsk_edge_table_truncate(self, (tsk_size_t) index);\n tsk_bug_assert(ret == 0);\n ret_id = tsk_edge_table_add_row(\n self, left, right, parent, child, metadata, metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n num_rows = 0;\n for (j = index + 1; j < (tsk_id_t) copy.num_rows; j++) {\n rows[num_rows] = j;\n num_rows++;\n }\n ret = tsk_edge_table_extend(self, ©, num_rows, rows, 0);\n if (ret != 0) {\n goto out;\n }\nout:\n tsk_edge_table_free(©);\n tsk_safe_free(rows);\n return ret;\n}\n\nint\ntsk_edge_table_update_row(tsk_edge_table_t *self, tsk_id_t index, double left,\n double right, tsk_id_t parent, tsk_id_t child, const char *metadata,\n tsk_size_t metadata_length)\n{\n int ret = 0;\n tsk_edge_t current_row;\n\n ret = tsk_edge_table_get_row(self, index, ¤t_row);\n if (ret != 0) {\n goto out;\n }\n if (current_row.metadata_length == metadata_length) {\n self->left[index] = left;\n self->right[index] = right;\n self->parent[index] = parent;\n self->child[index] = child;\n if (tsk_edge_table_has_metadata(self)) {\n /* Note: important to use tsk_memmove here as we may be provided pointers\n * to the column memory as input via get_row */\n tsk_memmove(&self->metadata[self->metadata_offset[index]], metadata,\n metadata_length * sizeof(*metadata));\n }\n } else {\n ret = tsk_edge_table_update_row_rewrite(\n self, index, left, right, parent, child, metadata, metadata_length);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_edge_table_copy(\n const tsk_edge_table_t *self, tsk_edge_table_t *dest, tsk_flags_t options)\n{\n int ret = 0;\n char *metadata = NULL;\n tsk_size_t *metadata_offset = NULL;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_edge_table_init(dest, options);\n if (ret != 0) {\n goto out;\n }\n }\n\n /* We can't use TSK_TABLE_NO_METADATA in dest if metadata_length is non-zero.\n * This also captures the case where TSK_TABLE_NO_METADATA is set on this table.\n */\n if (self->metadata_length > 0 && !tsk_edge_table_has_metadata(dest)) {\n ret = tsk_trace_error(TSK_ERR_METADATA_DISABLED);\n goto out;\n }\n if (tsk_edge_table_has_metadata(dest)) {\n metadata = self->metadata;\n metadata_offset = self->metadata_offset;\n }\n ret = tsk_edge_table_set_columns(dest, self->num_rows, self->left, self->right,\n self->parent, self->child, metadata, metadata_offset);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_edge_table_set_metadata_schema(\n dest, self->metadata_schema, self->metadata_schema_length);\nout:\n return ret;\n}\n\nint\ntsk_edge_table_set_columns(tsk_edge_table_t *self, tsk_size_t num_rows,\n const double *left, const double *right, const tsk_id_t *parent,\n const tsk_id_t *child, const char *metadata, const tsk_size_t *metadata_offset)\n{\n int ret = 0;\n\n ret = tsk_edge_table_clear(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_edge_table_append_columns(\n self, num_rows, left, right, parent, child, metadata, metadata_offset);\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_edge_table_takeset_columns(tsk_edge_table_t *self, tsk_size_t num_rows, double *left,\n double *right, tsk_id_t *parent, tsk_id_t *child, char *metadata,\n tsk_size_t *metadata_offset)\n{\n int ret = 0;\n\n /* We need to check all the inputs before we start freeing or taking memory */\n if (left == NULL || right == NULL || parent == NULL || child == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if (metadata != NULL && !tsk_edge_table_has_metadata(self)) {\n ret = tsk_trace_error(TSK_ERR_METADATA_DISABLED);\n goto out;\n }\n ret = check_ragged_column(num_rows, metadata, metadata_offset);\n if (ret != 0) {\n goto out;\n }\n\n tsk_edge_table_free_columns(self);\n self->num_rows = num_rows;\n self->max_rows = num_rows;\n self->left = left;\n self->right = right;\n self->parent = parent;\n self->child = child;\n\n ret = takeset_ragged_column(num_rows, metadata, metadata_offset,\n (void *) &self->metadata, &self->metadata_offset, &self->metadata_length);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nint\ntsk_edge_table_append_columns(tsk_edge_table_t *self, tsk_size_t num_rows,\n const double *left, const double *right, const tsk_id_t *parent,\n const tsk_id_t *child, const char *metadata, const tsk_size_t *metadata_offset)\n{\n int ret;\n tsk_size_t j, metadata_length;\n\n if (left == NULL || right == NULL || parent == NULL || child == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if ((metadata == NULL) != (metadata_offset == NULL)) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if (metadata != NULL && !tsk_edge_table_has_metadata(self)) {\n ret = tsk_trace_error(TSK_ERR_METADATA_DISABLED);\n goto out;\n }\n\n ret = tsk_edge_table_expand_main_columns(self, num_rows);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->left + self->num_rows, left, num_rows * sizeof(double));\n tsk_memcpy(self->right + self->num_rows, right, num_rows * sizeof(double));\n tsk_memcpy(self->parent + self->num_rows, parent, num_rows * sizeof(tsk_id_t));\n tsk_memcpy(self->child + self->num_rows, child, num_rows * sizeof(tsk_id_t));\n if (tsk_edge_table_has_metadata(self)) {\n if (metadata == NULL) {\n for (j = 0; j < num_rows; j++) {\n self->metadata_offset[self->num_rows + j + 1] = self->metadata_length;\n }\n } else {\n ret = check_offsets(num_rows, metadata_offset, 0, false);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n self->metadata_offset[self->num_rows + j]\n = (tsk_size_t) self->metadata_length + metadata_offset[j];\n }\n metadata_length = metadata_offset[num_rows];\n ret = tsk_edge_table_expand_metadata(self, metadata_length);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->metadata + self->metadata_length, metadata,\n metadata_length * sizeof(char));\n self->metadata_length += metadata_length;\n }\n self->num_rows += num_rows;\n self->metadata_offset[self->num_rows] = self->metadata_length;\n } else {\n self->num_rows += num_rows;\n }\nout:\n return ret;\n}\n\nint\ntsk_edge_table_clear(tsk_edge_table_t *self)\n{\n return tsk_edge_table_truncate(self, 0);\n}\n\nint\ntsk_edge_table_truncate(tsk_edge_table_t *self, tsk_size_t num_rows)\n{\n int ret = 0;\n\n if (num_rows > self->num_rows) {\n ret = tsk_trace_error(TSK_ERR_BAD_TABLE_POSITION);\n goto out;\n }\n self->num_rows = num_rows;\n if (tsk_edge_table_has_metadata(self)) {\n self->metadata_length = self->metadata_offset[num_rows];\n }\nout:\n return ret;\n}\n\nint\ntsk_edge_table_extend(tsk_edge_table_t *self, const tsk_edge_table_t *other,\n tsk_size_t num_rows, const tsk_id_t *row_indexes, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_edge_t edge;\n\n if (self == other) {\n ret = tsk_trace_error(TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n goto out;\n }\n\n /* We know how much to expand the non-ragged columns, so do it ahead of time */\n ret = tsk_edge_table_expand_main_columns(self, num_rows);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n ret = tsk_edge_table_get_row(\n other, row_indexes == NULL ? (tsk_id_t) j : row_indexes[j], &edge);\n if (ret != 0) {\n goto out;\n }\n ret_id = tsk_edge_table_add_row(self, edge.left, edge.right, edge.parent,\n edge.child, edge.metadata, edge.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nstatic inline void\ntsk_edge_table_get_row_unsafe(\n const tsk_edge_table_t *self, tsk_id_t index, tsk_edge_t *row)\n{\n row->id = (tsk_id_t) index;\n row->left = self->left[index];\n row->right = self->right[index];\n row->parent = self->parent[index];\n row->child = self->child[index];\n if (tsk_edge_table_has_metadata(self)) {\n row->metadata_length\n = self->metadata_offset[index + 1] - self->metadata_offset[index];\n row->metadata = self->metadata + self->metadata_offset[index];\n } else {\n row->metadata_length = 0;\n row->metadata = NULL;\n }\n}\n\nint\ntsk_edge_table_get_row(const tsk_edge_table_t *self, tsk_id_t index, tsk_edge_t *row)\n{\n int ret = 0;\n\n if (index < 0 || index >= (tsk_id_t) self->num_rows) {\n ret = tsk_trace_error(TSK_ERR_EDGE_OUT_OF_BOUNDS);\n goto out;\n }\n tsk_edge_table_get_row_unsafe(self, index, row);\nout:\n return ret;\n}\n\nvoid\ntsk_edge_table_print_state(const tsk_edge_table_t *self, FILE *out)\n{\n int ret;\n\n fprintf(out, \"\\n\" TABLE_SEP);\n fprintf(out, \"edge_table: %p:\\n\", (const void *) self);\n fprintf(out, \"options = 0x%X\\n\", self->options);\n fprintf(out, \"num_rows = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->num_rows, (long long) self->max_rows,\n (long long) self->max_rows_increment);\n fprintf(out, \"metadata_length = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->metadata_length, (long long) self->max_metadata_length,\n (long long) self->max_metadata_length_increment);\n fprintf(out, TABLE_SEP);\n ret = tsk_edge_table_dump_text(self, out);\n tsk_bug_assert(ret == 0);\n}\n\nint\ntsk_edge_table_set_metadata_schema(tsk_edge_table_t *self, const char *metadata_schema,\n tsk_size_t metadata_schema_length)\n{\n return replace_string(&self->metadata_schema, &self->metadata_schema_length,\n metadata_schema, metadata_schema_length);\n}\n\nint\ntsk_edge_table_dump_text(const tsk_edge_table_t *self, FILE *out)\n{\n tsk_id_t j;\n int ret = TSK_ERR_IO;\n tsk_edge_t row;\n int err;\n\n err = write_metadata_schema_header(\n out, self->metadata_schema, self->metadata_schema_length);\n if (err < 0) {\n goto out;\n }\n err = fprintf(out, \"id\\tleft\\tright\\tparent\\tchild\\tmetadata\\n\");\n if (err < 0) {\n goto out;\n }\n for (j = 0; j < (tsk_id_t) self->num_rows; j++) {\n tsk_edge_table_get_row_unsafe(self, j, &row);\n err = fprintf(out, \"%lld\\t%.3f\\t%.3f\\t%lld\\t%lld\\t%.*s\\n\", (long long) j,\n row.left, row.right, (long long) row.parent, (long long) row.child,\n (int) row.metadata_length, row.metadata);\n if (err < 0) {\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nbool\ntsk_edge_table_equals(\n const tsk_edge_table_t *self, const tsk_edge_table_t *other, tsk_flags_t options)\n{\n bool metadata_equal;\n bool ret\n = self->num_rows == other->num_rows\n && tsk_memcmp(self->left, other->left, self->num_rows * sizeof(double)) == 0\n && tsk_memcmp(self->right, other->right, self->num_rows * sizeof(double)) == 0\n && tsk_memcmp(self->parent, other->parent, self->num_rows * sizeof(tsk_id_t))\n == 0\n && tsk_memcmp(self->child, other->child, self->num_rows * sizeof(tsk_id_t))\n == 0;\n\n if (!(options & TSK_CMP_IGNORE_METADATA)) {\n ret = ret && self->metadata_schema_length == other->metadata_schema_length\n && tsk_memcmp(self->metadata_schema, other->metadata_schema,\n self->metadata_schema_length * sizeof(char))\n == 0;\n metadata_equal = false;\n if (self->metadata_length == other->metadata_length) {\n if (tsk_edge_table_has_metadata(self)\n && tsk_edge_table_has_metadata(other)) {\n metadata_equal\n = tsk_memcmp(self->metadata_offset, other->metadata_offset,\n (self->num_rows + 1) * sizeof(tsk_size_t))\n == 0\n && tsk_memcmp(self->metadata, other->metadata,\n self->metadata_length * sizeof(char))\n == 0;\n } else {\n /* The only way that the metadata lengths can be equal (which\n * we've already tested) and either one or the other of the tables\n * hasn't got metadata is if they are both zero length. */\n tsk_bug_assert(self->metadata_length == 0);\n metadata_equal = true;\n }\n }\n ret = ret && metadata_equal;\n }\n return ret;\n}\n\nint\ntsk_edge_table_keep_rows(tsk_edge_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t TSK_UNUSED(options), tsk_id_t *id_map)\n{\n int ret = 0;\n tsk_size_t remaining_rows;\n\n if (id_map != NULL) {\n keep_mask_to_id_map(self->num_rows, keep, id_map);\n }\n remaining_rows = subset_double_column(self->left, self->num_rows, keep);\n subset_double_column(self->right, self->num_rows, keep);\n subset_id_column(self->parent, self->num_rows, keep);\n subset_id_column(self->child, self->num_rows, keep);\n if (self->metadata_length > 0) {\n tsk_bug_assert(!(self->options & TSK_TABLE_NO_METADATA));\n self->metadata_length = subset_ragged_char_column(\n self->metadata, self->metadata_offset, self->num_rows, keep);\n }\n self->num_rows = remaining_rows;\n return ret;\n}\n\nstatic int\ntsk_edge_table_dump(const tsk_edge_table_t *self, kastore_t *store, tsk_flags_t options)\n{\n int ret = 0;\n const write_table_col_t write_cols[] = {\n { \"edges/left\", (void *) self->left, self->num_rows, KAS_FLOAT64 },\n { \"edges/right\", (void *) self->right, self->num_rows, KAS_FLOAT64 },\n { \"edges/parent\", (void *) self->parent, self->num_rows, TSK_ID_STORAGE_TYPE },\n { \"edges/child\", (void *) self->child, self->num_rows, TSK_ID_STORAGE_TYPE },\n { \"edges/metadata_schema\", (void *) self->metadata_schema,\n self->metadata_schema_length, KAS_UINT8 },\n { .name = NULL },\n };\n const write_table_ragged_col_t ragged_cols[] = {\n { \"edges/metadata\", (void *) self->metadata, self->metadata_length, KAS_UINT8,\n self->metadata_offset, self->num_rows },\n { .name = NULL },\n };\n\n /* TODO when the general code has been updated to only write out the\n * column when the lenght of ragged columns is > 0 we can get rid of\n * this special case here and use write_table. */\n ret = write_table_cols(store, write_cols, options);\n if (ret != 0) {\n goto out;\n }\n if (tsk_edge_table_has_metadata(self)) {\n ret = write_table_ragged_cols(store, ragged_cols, options);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_edge_table_load(tsk_edge_table_t *self, kastore_t *store)\n{\n int ret = 0;\n char *metadata_schema = NULL;\n double *left = NULL;\n double *right = NULL;\n tsk_id_t *parent = NULL;\n tsk_id_t *child = NULL;\n char *metadata = NULL;\n tsk_size_t *metadata_offset = NULL;\n tsk_size_t num_rows, metadata_length, metadata_schema_length;\n\n read_table_col_t cols[] = {\n { \"edges/left\", (void **) &left, KAS_FLOAT64, 0 },\n { \"edges/right\", (void **) &right, KAS_FLOAT64, 0 },\n { \"edges/parent\", (void **) &parent, TSK_ID_STORAGE_TYPE, 0 },\n { \"edges/child\", (void **) &child, TSK_ID_STORAGE_TYPE, 0 },\n { .name = NULL },\n };\n read_table_ragged_col_t ragged_cols[] = {\n { \"edges/metadata\", (void **) &metadata, &metadata_length, KAS_UINT8,\n &metadata_offset, TSK_COL_OPTIONAL },\n { .name = NULL },\n };\n read_table_property_t properties[] = {\n { \"edges/metadata_schema\", (void **) &metadata_schema, &metadata_schema_length,\n KAS_UINT8, TSK_COL_OPTIONAL },\n { .name = NULL },\n };\n\n ret = read_table(store, &num_rows, cols, ragged_cols, properties, 0);\n if (ret != 0) {\n goto out;\n }\n if (metadata_schema != NULL) {\n ret = tsk_edge_table_set_metadata_schema(\n self, metadata_schema, metadata_schema_length);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_edge_table_takeset_columns(\n self, num_rows, left, right, parent, child, metadata, metadata_offset);\n if (ret != 0) {\n goto out;\n }\n left = NULL;\n right = NULL;\n parent = NULL;\n child = NULL;\n metadata = NULL;\n metadata_offset = NULL;\nout:\n free_read_table_mem(cols, ragged_cols, properties);\n return ret;\n}\n\nint\ntsk_edge_table_squash(tsk_edge_table_t *self)\n{\n int k;\n int ret = 0;\n tsk_edge_t *edges = NULL;\n tsk_size_t num_output_edges;\n\n if (self->metadata_length > 0) {\n ret = tsk_trace_error(TSK_ERR_CANT_PROCESS_EDGES_WITH_METADATA);\n goto out;\n }\n\n edges = tsk_malloc(self->num_rows * sizeof(tsk_edge_t));\n if (edges == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n for (k = 0; k < (int) self->num_rows; k++) {\n edges[k].left = self->left[k];\n edges[k].right = self->right[k];\n edges[k].parent = self->parent[k];\n edges[k].child = self->child[k];\n edges[k].metadata_length = 0;\n }\n\n ret = tsk_squash_edges(edges, self->num_rows, &num_output_edges);\n if (ret != 0) {\n goto out;\n }\n tsk_edge_table_clear(self);\n tsk_bug_assert(num_output_edges <= self->max_rows);\n self->num_rows = num_output_edges;\n for (k = 0; k < (int) num_output_edges; k++) {\n self->left[k] = edges[k].left;\n self->right[k] = edges[k].right;\n self->parent[k] = edges[k].parent;\n self->child[k] = edges[k].child;\n }\nout:\n tsk_safe_free(edges);\n return ret;\n}\n\n/*************************\n * site table\n *************************/\n\nstatic void\ntsk_site_table_free_columns(tsk_site_table_t *self)\n{\n tsk_safe_free(self->position);\n tsk_safe_free(self->ancestral_state);\n tsk_safe_free(self->ancestral_state_offset);\n tsk_safe_free(self->metadata);\n tsk_safe_free(self->metadata_offset);\n}\n\nint\ntsk_site_table_free(tsk_site_table_t *self)\n{\n tsk_site_table_free_columns(self);\n tsk_safe_free(self->metadata_schema);\n return 0;\n}\n\nstatic int\ntsk_site_table_expand_main_columns(tsk_site_table_t *self, tsk_size_t additional_rows)\n{\n int ret = 0;\n tsk_size_t new_max_rows;\n\n ret = calculate_max_rows(self->num_rows, self->max_rows, self->max_rows_increment,\n additional_rows, &new_max_rows);\n if (ret != 0) {\n goto out;\n }\n if ((self->num_rows + additional_rows) > self->max_rows) {\n ret = expand_column((void **) &self->position, new_max_rows, sizeof(double));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column((void **) &self->ancestral_state_offset, new_max_rows + 1,\n sizeof(tsk_size_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column(\n (void **) &self->metadata_offset, new_max_rows + 1, sizeof(tsk_size_t));\n if (ret != 0) {\n goto out;\n }\n self->max_rows = new_max_rows;\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_site_table_expand_ancestral_state(\n tsk_site_table_t *self, tsk_size_t additional_length)\n{\n return expand_ragged_column(self->ancestral_state_length, additional_length,\n self->max_ancestral_state_length_increment, &self->max_ancestral_state_length,\n (void **) &self->ancestral_state, sizeof(*self->ancestral_state));\n}\n\nstatic int\ntsk_site_table_expand_metadata(tsk_site_table_t *self, tsk_size_t additional_length)\n{\n return expand_ragged_column(self->metadata_length, additional_length,\n self->max_metadata_length_increment, &self->max_metadata_length,\n (void **) &self->metadata, sizeof(*self->metadata));\n}\n\nint\ntsk_site_table_set_max_rows_increment(\n tsk_site_table_t *self, tsk_size_t max_rows_increment)\n{\n self->max_rows_increment = max_rows_increment;\n return 0;\n}\n\nint\ntsk_site_table_set_max_metadata_length_increment(\n tsk_site_table_t *self, tsk_size_t max_metadata_length_increment)\n{\n self->max_metadata_length_increment = max_metadata_length_increment;\n return 0;\n}\n\nint\ntsk_site_table_set_max_ancestral_state_length_increment(\n tsk_site_table_t *self, tsk_size_t max_ancestral_state_length_increment)\n{\n self->max_ancestral_state_length_increment = max_ancestral_state_length_increment;\n return 0;\n}\n\nint\ntsk_site_table_init(tsk_site_table_t *self, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n\n tsk_memset(self, 0, sizeof(tsk_site_table_t));\n\n /* Allocate space for one row initially, ensuring we always have valid pointers\n * even if the table is empty */\n self->max_rows_increment = 1;\n self->max_ancestral_state_length_increment = 1;\n self->max_metadata_length_increment = 1;\n ret = tsk_site_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_site_table_expand_ancestral_state(self, 1);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_site_table_expand_metadata(self, 1);\n if (ret != 0) {\n goto out;\n }\n self->ancestral_state_offset[0] = 0;\n self->metadata_offset[0] = 0;\n self->max_rows_increment = 0;\n self->max_ancestral_state_length_increment = 0;\n self->max_metadata_length_increment = 0;\n tsk_site_table_set_metadata_schema(self, NULL, 0);\nout:\n return ret;\n}\n\ntsk_id_t\ntsk_site_table_add_row(tsk_site_table_t *self, double position,\n const char *ancestral_state, tsk_size_t ancestral_state_length, const char *metadata,\n tsk_size_t metadata_length)\n{\n tsk_id_t ret = 0;\n tsk_size_t ancestral_state_offset, metadata_offset;\n\n ret = tsk_site_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n self->position[self->num_rows] = position;\n\n ancestral_state_offset = (tsk_size_t) self->ancestral_state_length;\n tsk_bug_assert(\n self->ancestral_state_offset[self->num_rows] == ancestral_state_offset);\n ret = tsk_site_table_expand_ancestral_state(self, ancestral_state_length);\n if (ret != 0) {\n goto out;\n }\n self->ancestral_state_length += ancestral_state_length;\n tsk_memmove(self->ancestral_state + ancestral_state_offset, ancestral_state,\n ancestral_state_length);\n self->ancestral_state_offset[self->num_rows + 1] = self->ancestral_state_length;\n\n metadata_offset = (tsk_size_t) self->metadata_length;\n tsk_bug_assert(self->metadata_offset[self->num_rows] == metadata_offset);\n ret = tsk_site_table_expand_metadata(self, metadata_length);\n if (ret != 0) {\n goto out;\n }\n self->metadata_length += metadata_length;\n tsk_memmove(self->metadata + metadata_offset, metadata, metadata_length);\n self->metadata_offset[self->num_rows + 1] = self->metadata_length;\n\n ret = (tsk_id_t) self->num_rows;\n self->num_rows++;\nout:\n return ret;\n}\n\nstatic int\ntsk_site_table_update_row_rewrite(tsk_site_table_t *self, tsk_id_t index,\n double position, const char *ancestral_state, tsk_size_t ancestral_state_length,\n const char *metadata, tsk_size_t metadata_length)\n{\n int ret = 0;\n tsk_id_t j, ret_id;\n tsk_site_table_t copy;\n tsk_size_t num_rows;\n tsk_id_t *rows = NULL;\n\n ret = tsk_site_table_copy(self, ©, 0);\n if (ret != 0) {\n goto out;\n }\n rows = tsk_malloc(self->num_rows * sizeof(*rows));\n if (rows == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n ret = tsk_site_table_truncate(self, (tsk_size_t) index);\n tsk_bug_assert(ret == 0);\n ret_id = tsk_site_table_add_row(self, position, ancestral_state,\n ancestral_state_length, metadata, metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n num_rows = 0;\n for (j = index + 1; j < (tsk_id_t) copy.num_rows; j++) {\n rows[num_rows] = j;\n num_rows++;\n }\n ret = tsk_site_table_extend(self, ©, num_rows, rows, 0);\n if (ret != 0) {\n goto out;\n }\nout:\n tsk_site_table_free(©);\n tsk_safe_free(rows);\n return ret;\n}\n\nint\ntsk_site_table_update_row(tsk_site_table_t *self, tsk_id_t index, double position,\n const char *ancestral_state, tsk_size_t ancestral_state_length, const char *metadata,\n tsk_size_t metadata_length)\n{\n int ret = 0;\n tsk_site_t current_row;\n\n ret = tsk_site_table_get_row(self, index, ¤t_row);\n if (ret != 0) {\n goto out;\n }\n if (current_row.metadata_length == metadata_length\n && current_row.ancestral_state_length == ancestral_state_length) {\n self->position[index] = position;\n /* Note: important to use tsk_memmove here as we may be provided pointers\n * to the column memory as input via get_row */\n tsk_memmove(&self->ancestral_state[self->ancestral_state_offset[index]],\n ancestral_state, ancestral_state_length * sizeof(*ancestral_state));\n tsk_memmove(&self->metadata[self->metadata_offset[index]], metadata,\n metadata_length * sizeof(*metadata));\n } else {\n ret = tsk_site_table_update_row_rewrite(self, index, position, ancestral_state,\n ancestral_state_length, metadata, metadata_length);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nint\ntsk_site_table_append_columns(tsk_site_table_t *self, tsk_size_t num_rows,\n const double *position, const char *ancestral_state,\n const tsk_size_t *ancestral_state_offset, const char *metadata,\n const tsk_size_t *metadata_offset)\n{\n int ret = 0;\n tsk_size_t j, ancestral_state_length, metadata_length;\n\n if (position == NULL || ancestral_state == NULL || ancestral_state_offset == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if ((metadata == NULL) != (metadata_offset == NULL)) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n\n ret = tsk_site_table_expand_main_columns(self, num_rows);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->position + self->num_rows, position, num_rows * sizeof(double));\n\n /* Metadata column */\n if (metadata == NULL) {\n for (j = 0; j < num_rows; j++) {\n self->metadata_offset[self->num_rows + j + 1] = self->metadata_length;\n }\n } else {\n ret = check_offsets(num_rows, metadata_offset, 0, false);\n if (ret != 0) {\n goto out;\n }\n metadata_length = metadata_offset[num_rows];\n ret = tsk_site_table_expand_metadata(self, metadata_length);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->metadata + self->metadata_length, metadata,\n metadata_length * sizeof(char));\n for (j = 0; j < num_rows; j++) {\n self->metadata_offset[self->num_rows + j]\n = self->metadata_length + metadata_offset[j];\n }\n self->metadata_length += metadata_length;\n }\n self->metadata_offset[self->num_rows + num_rows] = self->metadata_length;\n\n /* Ancestral state column */\n ret = check_offsets(num_rows, ancestral_state_offset, 0, false);\n if (ret != 0) {\n goto out;\n }\n ancestral_state_length = ancestral_state_offset[num_rows];\n ret = tsk_site_table_expand_ancestral_state(self, ancestral_state_length);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->ancestral_state + self->ancestral_state_length, ancestral_state,\n ancestral_state_length * sizeof(char));\n for (j = 0; j < num_rows; j++) {\n self->ancestral_state_offset[self->num_rows + j]\n = self->ancestral_state_length + ancestral_state_offset[j];\n }\n self->ancestral_state_length += ancestral_state_length;\n self->ancestral_state_offset[self->num_rows + num_rows]\n = self->ancestral_state_length;\n\n self->num_rows += num_rows;\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_site_table_copy(\n const tsk_site_table_t *self, tsk_site_table_t *dest, tsk_flags_t options)\n{\n int ret = 0;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_site_table_init(dest, 0);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_site_table_set_columns(dest, self->num_rows, self->position,\n self->ancestral_state, self->ancestral_state_offset, self->metadata,\n self->metadata_offset);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_site_table_set_metadata_schema(\n dest, self->metadata_schema, self->metadata_schema_length);\nout:\n return ret;\n}\n\nint\ntsk_site_table_set_columns(tsk_site_table_t *self, tsk_size_t num_rows,\n const double *position, const char *ancestral_state,\n const tsk_size_t *ancestral_state_offset, const char *metadata,\n const tsk_size_t *metadata_offset)\n{\n int ret = 0;\n\n ret = tsk_site_table_clear(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_site_table_append_columns(self, num_rows, position, ancestral_state,\n ancestral_state_offset, metadata, metadata_offset);\nout:\n return ret;\n}\n\nint\ntsk_site_table_takeset_columns(tsk_site_table_t *self, tsk_size_t num_rows,\n double *position, char *ancestral_state, tsk_size_t *ancestral_state_offset,\n char *metadata, tsk_size_t *metadata_offset)\n{\n int ret = 0;\n\n /* We need to check all the inputs before we start freeing or taking memory */\n if (position == NULL || ancestral_state == NULL || ancestral_state_offset == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n ret = check_ragged_column(num_rows, ancestral_state, ancestral_state_offset);\n if (ret != 0) {\n goto out;\n }\n ret = check_ragged_column(num_rows, metadata, metadata_offset);\n if (ret != 0) {\n goto out;\n }\n\n tsk_site_table_free_columns(self);\n self->num_rows = num_rows;\n self->max_rows = num_rows;\n self->position = position;\n\n ret = takeset_ragged_column(num_rows, ancestral_state, ancestral_state_offset,\n (void *) &self->ancestral_state, &self->ancestral_state_offset,\n &self->ancestral_state_length);\n if (ret != 0) {\n goto out;\n }\n ret = takeset_ragged_column(num_rows, metadata, metadata_offset,\n (void *) &self->metadata, &self->metadata_offset, &self->metadata_length);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nbool\ntsk_site_table_equals(\n const tsk_site_table_t *self, const tsk_site_table_t *other, tsk_flags_t options)\n{\n bool ret\n = self->num_rows == other->num_rows\n && self->ancestral_state_length == other->ancestral_state_length\n && tsk_memcmp(self->position, other->position, self->num_rows * sizeof(double))\n == 0\n && tsk_memcmp(self->ancestral_state_offset, other->ancestral_state_offset,\n (self->num_rows + 1) * sizeof(tsk_size_t))\n == 0\n && tsk_memcmp(self->ancestral_state, other->ancestral_state,\n self->ancestral_state_length * sizeof(char))\n == 0;\n if (!(options & TSK_CMP_IGNORE_METADATA)) {\n ret = ret && self->metadata_length == other->metadata_length\n && self->metadata_schema_length == other->metadata_schema_length\n && tsk_memcmp(self->metadata_offset, other->metadata_offset,\n (self->num_rows + 1) * sizeof(tsk_size_t))\n == 0\n && tsk_memcmp(self->metadata, other->metadata,\n self->metadata_length * sizeof(char))\n == 0\n && tsk_memcmp(self->metadata_schema, other->metadata_schema,\n self->metadata_schema_length * sizeof(char))\n == 0;\n }\n return ret;\n}\n\nint\ntsk_site_table_clear(tsk_site_table_t *self)\n{\n return tsk_site_table_truncate(self, 0);\n}\n\nint\ntsk_site_table_truncate(tsk_site_table_t *self, tsk_size_t num_rows)\n{\n int ret = 0;\n\n if (num_rows > self->num_rows) {\n ret = tsk_trace_error(TSK_ERR_BAD_TABLE_POSITION);\n goto out;\n }\n self->num_rows = num_rows;\n self->ancestral_state_length = self->ancestral_state_offset[num_rows];\n self->metadata_length = self->metadata_offset[num_rows];\nout:\n return ret;\n}\n\nint\ntsk_site_table_extend(tsk_site_table_t *self, const tsk_site_table_t *other,\n tsk_size_t num_rows, const tsk_id_t *row_indexes, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_site_t site;\n\n if (self == other) {\n ret = tsk_trace_error(TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n goto out;\n }\n\n /* We know how much to expand the non-ragged columns, so do it ahead of time */\n ret = tsk_site_table_expand_main_columns(self, num_rows);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n ret = tsk_site_table_get_row(\n other, row_indexes == NULL ? (tsk_id_t) j : row_indexes[j], &site);\n if (ret != 0) {\n goto out;\n }\n ret_id = tsk_site_table_add_row(self, site.position, site.ancestral_state,\n site.ancestral_state_length, site.metadata, site.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nvoid\ntsk_site_table_print_state(const tsk_site_table_t *self, FILE *out)\n{\n int ret;\n\n fprintf(out, \"\\n\" TABLE_SEP);\n fprintf(out, \"site_table: %p:\\n\", (const void *) self);\n fprintf(out, \"num_rows = %lld\\t(max= %lld\\tincrement = %lld)\\n\",\n (long long) self->num_rows, (long long) self->max_rows,\n (long long) self->max_rows_increment);\n fprintf(out, \"ancestral_state_length = %lld\\t(max= %lld\\tincrement = %lld)\\n\",\n (long long) self->ancestral_state_length,\n (long long) self->max_ancestral_state_length,\n (long long) self->max_ancestral_state_length_increment);\n fprintf(out, \"metadata_length = %lld(\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->metadata_length, (long long) self->max_metadata_length,\n (long long) self->max_metadata_length_increment);\n fprintf(out, TABLE_SEP);\n ret = tsk_site_table_dump_text(self, out);\n tsk_bug_assert(ret == 0);\n\n tsk_bug_assert(self->ancestral_state_offset[0] == 0);\n tsk_bug_assert(\n self->ancestral_state_length == self->ancestral_state_offset[self->num_rows]);\n tsk_bug_assert(self->metadata_offset[0] == 0);\n tsk_bug_assert(self->metadata_length == self->metadata_offset[self->num_rows]);\n}\n\nstatic inline void\ntsk_site_table_get_row_unsafe(\n const tsk_site_table_t *self, tsk_id_t index, tsk_site_t *row)\n{\n row->id = (tsk_id_t) index;\n row->position = self->position[index];\n row->ancestral_state_length\n = self->ancestral_state_offset[index + 1] - self->ancestral_state_offset[index];\n row->ancestral_state = self->ancestral_state + self->ancestral_state_offset[index];\n row->metadata_length\n = self->metadata_offset[index + 1] - self->metadata_offset[index];\n row->metadata = self->metadata + self->metadata_offset[index];\n /* This struct has a placeholder for mutations. Probably should be separate\n * structs for this (tsk_site_table_row_t?) */\n row->mutations_length = 0;\n row->mutations = NULL;\n}\n\nint\ntsk_site_table_get_row(const tsk_site_table_t *self, tsk_id_t index, tsk_site_t *row)\n{\n int ret = 0;\n\n if (index < 0 || index >= (tsk_id_t) self->num_rows) {\n ret = tsk_trace_error(TSK_ERR_SITE_OUT_OF_BOUNDS);\n goto out;\n }\n tsk_site_table_get_row_unsafe(self, index, row);\nout:\n return ret;\n}\n\nint\ntsk_site_table_set_metadata_schema(tsk_site_table_t *self, const char *metadata_schema,\n tsk_size_t metadata_schema_length)\n{\n return replace_string(&self->metadata_schema, &self->metadata_schema_length,\n metadata_schema, metadata_schema_length);\n}\n\nint\ntsk_site_table_dump_text(const tsk_site_table_t *self, FILE *out)\n{\n tsk_size_t j;\n int ret = TSK_ERR_IO;\n int err;\n tsk_size_t ancestral_state_len, metadata_len;\n\n err = write_metadata_schema_header(\n out, self->metadata_schema, self->metadata_schema_length);\n if (err < 0) {\n goto out;\n }\n err = fprintf(out, \"id\\tposition\\tancestral_state\\tmetadata\\n\");\n if (err < 0) {\n goto out;\n }\n for (j = 0; j < self->num_rows; j++) {\n ancestral_state_len\n = self->ancestral_state_offset[j + 1] - self->ancestral_state_offset[j];\n metadata_len = self->metadata_offset[j + 1] - self->metadata_offset[j];\n err = fprintf(out, \"%lld\\t%f\\t%.*s\\t%.*s\\n\", (long long) j, self->position[j],\n (int) ancestral_state_len,\n self->ancestral_state + self->ancestral_state_offset[j], (int) metadata_len,\n self->metadata + self->metadata_offset[j]);\n if (err < 0) {\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nint\ntsk_site_table_keep_rows(tsk_site_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t TSK_UNUSED(options), tsk_id_t *id_map)\n{\n int ret = 0;\n tsk_size_t remaining_rows;\n\n if (id_map != NULL) {\n keep_mask_to_id_map(self->num_rows, keep, id_map);\n }\n\n remaining_rows = subset_double_column(self->position, self->num_rows, keep);\n self->ancestral_state_length = subset_ragged_char_column(\n self->ancestral_state, self->ancestral_state_offset, self->num_rows, keep);\n if (self->metadata_length > 0) {\n self->metadata_length = subset_ragged_char_column(\n self->metadata, self->metadata_offset, self->num_rows, keep);\n }\n self->num_rows = remaining_rows;\n return ret;\n}\n\nstatic int\ntsk_site_table_dump(const tsk_site_table_t *self, kastore_t *store, tsk_flags_t options)\n{\n const write_table_col_t cols[] = {\n { \"sites/position\", (void *) self->position, self->num_rows, KAS_FLOAT64 },\n { \"sites/metadata_schema\", (void *) self->metadata_schema,\n self->metadata_schema_length, KAS_UINT8 },\n { .name = NULL },\n };\n const write_table_ragged_col_t ragged_cols[] = {\n { \"sites/ancestral_state\", (void *) self->ancestral_state,\n self->ancestral_state_length, KAS_UINT8, self->ancestral_state_offset,\n self->num_rows },\n { \"sites/metadata\", (void *) self->metadata, self->metadata_length, KAS_UINT8,\n self->metadata_offset, self->num_rows },\n { .name = NULL },\n };\n\n return write_table(store, cols, ragged_cols, options);\n}\n\nstatic int\ntsk_site_table_load(tsk_site_table_t *self, kastore_t *store)\n{\n int ret = 0;\n char *metadata_schema = NULL;\n double *position = NULL;\n char *ancestral_state = NULL;\n tsk_size_t *ancestral_state_offset = NULL;\n char *metadata = NULL;\n tsk_size_t *metadata_offset = NULL;\n tsk_size_t num_rows, ancestral_state_length, metadata_length, metadata_schema_length;\n\n read_table_col_t cols[] = {\n { \"sites/position\", (void **) &position, KAS_FLOAT64, 0 },\n { .name = NULL },\n };\n read_table_ragged_col_t ragged_cols[] = {\n { \"sites/ancestral_state\", (void **) &ancestral_state, &ancestral_state_length,\n KAS_UINT8, &ancestral_state_offset, 0 },\n { \"sites/metadata\", (void **) &metadata, &metadata_length, KAS_UINT8,\n &metadata_offset, 0 },\n { .name = NULL },\n };\n read_table_property_t properties[] = {\n { \"sites/metadata_schema\", (void **) &metadata_schema, &metadata_schema_length,\n KAS_UINT8, TSK_COL_OPTIONAL },\n { .name = NULL },\n };\n\n ret = read_table(store, &num_rows, cols, ragged_cols, properties, 0);\n if (ret != 0) {\n goto out;\n }\n if (metadata_schema != NULL) {\n ret = tsk_site_table_set_metadata_schema(\n self, metadata_schema, metadata_schema_length);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_site_table_takeset_columns(self, num_rows, position, ancestral_state,\n ancestral_state_offset, metadata, metadata_offset);\n if (ret != 0) {\n goto out;\n }\n position = NULL;\n ancestral_state = NULL;\n ancestral_state_offset = NULL;\n metadata = NULL;\n metadata_offset = NULL;\n\nout:\n free_read_table_mem(cols, ragged_cols, properties);\n return ret;\n}\n\n/*************************\n * mutation table\n *************************/\n\nstatic void\ntsk_mutation_table_free_columns(tsk_mutation_table_t *self)\n{\n tsk_safe_free(self->node);\n tsk_safe_free(self->site);\n tsk_safe_free(self->parent);\n tsk_safe_free(self->time);\n tsk_safe_free(self->derived_state);\n tsk_safe_free(self->derived_state_offset);\n tsk_safe_free(self->metadata);\n tsk_safe_free(self->metadata_offset);\n}\n\nint\ntsk_mutation_table_free(tsk_mutation_table_t *self)\n{\n tsk_mutation_table_free_columns(self);\n tsk_safe_free(self->metadata_schema);\n return 0;\n}\n\nstatic int\ntsk_mutation_table_expand_main_columns(\n tsk_mutation_table_t *self, tsk_size_t additional_rows)\n{\n int ret = 0;\n tsk_size_t new_max_rows;\n\n ret = calculate_max_rows(self->num_rows, self->max_rows, self->max_rows_increment,\n additional_rows, &new_max_rows);\n if (ret != 0) {\n goto out;\n }\n if ((self->num_rows + additional_rows) > self->max_rows) {\n ret = expand_column((void **) &self->site, new_max_rows, sizeof(tsk_id_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column((void **) &self->node, new_max_rows, sizeof(tsk_id_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column((void **) &self->parent, new_max_rows, sizeof(tsk_id_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column((void **) &self->time, new_max_rows, sizeof(double));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column(\n (void **) &self->derived_state_offset, new_max_rows + 1, sizeof(tsk_size_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column(\n (void **) &self->metadata_offset, new_max_rows + 1, sizeof(tsk_size_t));\n if (ret != 0) {\n goto out;\n }\n self->max_rows = new_max_rows;\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_mutation_table_expand_derived_state(\n tsk_mutation_table_t *self, tsk_size_t additional_length)\n{\n return expand_ragged_column(self->derived_state_length, additional_length,\n self->max_derived_state_length_increment, &self->max_derived_state_length,\n (void **) &self->derived_state, sizeof(*self->derived_state));\n}\n\nstatic int\ntsk_mutation_table_expand_metadata(\n tsk_mutation_table_t *self, tsk_size_t additional_length)\n{\n return expand_ragged_column(self->metadata_length, additional_length,\n self->max_metadata_length_increment, &self->max_metadata_length,\n (void **) &self->metadata, sizeof(*self->metadata));\n}\n\nint\ntsk_mutation_table_set_max_rows_increment(\n tsk_mutation_table_t *self, tsk_size_t max_rows_increment)\n{\n self->max_rows_increment = max_rows_increment;\n return 0;\n}\n\nint\ntsk_mutation_table_set_max_metadata_length_increment(\n tsk_mutation_table_t *self, tsk_size_t max_metadata_length_increment)\n{\n self->max_metadata_length_increment = max_metadata_length_increment;\n return 0;\n}\n\nint\ntsk_mutation_table_set_max_derived_state_length_increment(\n tsk_mutation_table_t *self, tsk_size_t max_derived_state_length_increment)\n{\n self->max_derived_state_length_increment = max_derived_state_length_increment;\n return 0;\n}\n\nint\ntsk_mutation_table_init(tsk_mutation_table_t *self, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n\n tsk_memset(self, 0, sizeof(tsk_mutation_table_t));\n\n /* Allocate space for one row initially, ensuring we always have valid pointers\n * even if the table is empty */\n self->max_rows_increment = 1;\n self->max_derived_state_length_increment = 1;\n self->max_metadata_length_increment = 1;\n ret = tsk_mutation_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_mutation_table_expand_derived_state(self, 1);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_mutation_table_expand_metadata(self, 1);\n if (ret != 0) {\n goto out;\n }\n self->derived_state_offset[0] = 0;\n self->metadata_offset[0] = 0;\n self->max_rows_increment = 0;\n self->max_derived_state_length_increment = 0;\n self->max_metadata_length_increment = 0;\n tsk_mutation_table_set_metadata_schema(self, NULL, 0);\nout:\n return ret;\n}\n\ntsk_id_t\ntsk_mutation_table_add_row(tsk_mutation_table_t *self, tsk_id_t site, tsk_id_t node,\n tsk_id_t parent, double time, const char *derived_state,\n tsk_size_t derived_state_length, const char *metadata, tsk_size_t metadata_length)\n{\n tsk_id_t ret;\n tsk_size_t derived_state_offset, metadata_offset;\n\n ret = tsk_mutation_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n self->site[self->num_rows] = site;\n self->node[self->num_rows] = node;\n self->parent[self->num_rows] = parent;\n self->time[self->num_rows] = time;\n\n derived_state_offset = self->derived_state_length;\n tsk_bug_assert(self->derived_state_offset[self->num_rows] == derived_state_offset);\n ret = tsk_mutation_table_expand_derived_state(self, derived_state_length);\n if (ret != 0) {\n goto out;\n }\n self->derived_state_length += derived_state_length;\n tsk_memmove(\n self->derived_state + derived_state_offset, derived_state, derived_state_length);\n self->derived_state_offset[self->num_rows + 1] = self->derived_state_length;\n\n metadata_offset = self->metadata_length;\n tsk_bug_assert(self->metadata_offset[self->num_rows] == metadata_offset);\n ret = tsk_mutation_table_expand_metadata(self, metadata_length);\n if (ret != 0) {\n goto out;\n }\n self->metadata_length += metadata_length;\n tsk_memmove(self->metadata + metadata_offset, metadata, metadata_length);\n self->metadata_offset[self->num_rows + 1] = self->metadata_length;\n\n ret = (tsk_id_t) self->num_rows;\n self->num_rows++;\nout:\n return ret;\n}\n\nstatic int\ntsk_mutation_table_update_row_rewrite(tsk_mutation_table_t *self, tsk_id_t index,\n tsk_id_t site, tsk_id_t node, tsk_id_t parent, double time,\n const char *derived_state, tsk_size_t derived_state_length, const char *metadata,\n tsk_size_t metadata_length)\n{\n int ret = 0;\n tsk_id_t j, ret_id;\n tsk_mutation_table_t copy;\n tsk_size_t num_rows;\n tsk_id_t *rows = NULL;\n\n ret = tsk_mutation_table_copy(self, ©, 0);\n if (ret != 0) {\n goto out;\n }\n rows = tsk_malloc(self->num_rows * sizeof(*rows));\n if (rows == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n ret = tsk_mutation_table_truncate(self, (tsk_size_t) index);\n tsk_bug_assert(ret == 0);\n ret_id = tsk_mutation_table_add_row(self, site, node, parent, time, derived_state,\n derived_state_length, metadata, metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n num_rows = 0;\n for (j = index + 1; j < (tsk_id_t) copy.num_rows; j++) {\n rows[num_rows] = j;\n num_rows++;\n }\n ret = tsk_mutation_table_extend(self, ©, num_rows, rows, 0);\n if (ret != 0) {\n goto out;\n }\nout:\n tsk_mutation_table_free(©);\n tsk_safe_free(rows);\n return ret;\n}\n\nint\ntsk_mutation_table_update_row(tsk_mutation_table_t *self, tsk_id_t index, tsk_id_t site,\n tsk_id_t node, tsk_id_t parent, double time, const char *derived_state,\n tsk_size_t derived_state_length, const char *metadata, tsk_size_t metadata_length)\n{\n int ret = 0;\n tsk_mutation_t current_row;\n\n ret = tsk_mutation_table_get_row(self, index, ¤t_row);\n if (ret != 0) {\n goto out;\n }\n if (current_row.metadata_length == metadata_length\n && current_row.derived_state_length == derived_state_length) {\n self->site[index] = site;\n self->node[index] = node;\n self->parent[index] = parent;\n self->time[index] = time;\n /* Note: important to use tsk_memmove here as we may be provided pointers\n * to the column memory as input via get_row */\n tsk_memmove(&self->derived_state[self->derived_state_offset[index]],\n derived_state, derived_state_length * sizeof(*derived_state));\n tsk_memmove(&self->metadata[self->metadata_offset[index]], metadata,\n metadata_length * sizeof(*metadata));\n } else {\n ret = tsk_mutation_table_update_row_rewrite(self, index, site, node, parent,\n time, derived_state, derived_state_length, metadata, metadata_length);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nint\ntsk_mutation_table_append_columns(tsk_mutation_table_t *self, tsk_size_t num_rows,\n const tsk_id_t *site, const tsk_id_t *node, const tsk_id_t *parent,\n const double *time, const char *derived_state,\n const tsk_size_t *derived_state_offset, const char *metadata,\n const tsk_size_t *metadata_offset)\n{\n int ret = 0;\n tsk_size_t j, derived_state_length, metadata_length;\n\n if (site == NULL || node == NULL || derived_state == NULL\n || derived_state_offset == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if ((metadata == NULL) != (metadata_offset == NULL)) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n\n ret = tsk_mutation_table_expand_main_columns(self, num_rows);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->site + self->num_rows, site, num_rows * sizeof(tsk_id_t));\n tsk_memcpy(self->node + self->num_rows, node, num_rows * sizeof(tsk_id_t));\n if (parent == NULL) {\n /* If parent is NULL, set all parents to the null mutation */\n tsk_memset(self->parent + self->num_rows, 0xff, num_rows * sizeof(tsk_id_t));\n } else {\n tsk_memcpy(self->parent + self->num_rows, parent, num_rows * sizeof(tsk_id_t));\n }\n if (time == NULL) {\n /* If time is NULL, set all times to TSK_UNKNOWN_TIME which is the\n * default */\n for (j = 0; j < num_rows; j++) {\n self->time[self->num_rows + j] = TSK_UNKNOWN_TIME;\n }\n } else {\n tsk_memcpy(self->time + self->num_rows, time, num_rows * sizeof(double));\n }\n\n /* Metadata column */\n if (metadata == NULL) {\n for (j = 0; j < num_rows; j++) {\n self->metadata_offset[self->num_rows + j + 1] = self->metadata_length;\n }\n } else {\n ret = check_offsets(num_rows, metadata_offset, 0, false);\n if (ret != 0) {\n goto out;\n }\n metadata_length = metadata_offset[num_rows];\n ret = tsk_mutation_table_expand_metadata(self, metadata_length);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->metadata + self->metadata_length, metadata,\n metadata_length * sizeof(char));\n for (j = 0; j < num_rows; j++) {\n self->metadata_offset[self->num_rows + j]\n = self->metadata_length + metadata_offset[j];\n }\n self->metadata_length += metadata_length;\n }\n self->metadata_offset[self->num_rows + num_rows] = self->metadata_length;\n\n /* Derived state column */\n ret = check_offsets(num_rows, derived_state_offset, 0, false);\n if (ret != 0) {\n goto out;\n }\n derived_state_length = derived_state_offset[num_rows];\n ret = tsk_mutation_table_expand_derived_state(self, derived_state_length);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->derived_state + self->derived_state_length, derived_state,\n derived_state_length * sizeof(char));\n for (j = 0; j < num_rows; j++) {\n self->derived_state_offset[self->num_rows + j]\n = self->derived_state_length + derived_state_offset[j];\n }\n self->derived_state_length += derived_state_length;\n self->derived_state_offset[self->num_rows + num_rows] = self->derived_state_length;\n\n self->num_rows += num_rows;\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_mutation_table_takeset_columns(tsk_mutation_table_t *self, tsk_size_t num_rows,\n tsk_id_t *site, tsk_id_t *node, tsk_id_t *parent, double *time, char *derived_state,\n tsk_size_t *derived_state_offset, char *metadata, tsk_size_t *metadata_offset)\n{\n tsk_size_t j;\n int ret = 0;\n\n if (site == NULL || node == NULL || derived_state == NULL\n || derived_state_offset == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n /* We need to check all the inputs before we start freeing or taking memory */\n ret = check_ragged_column(num_rows, derived_state, derived_state_offset);\n if (ret != 0) {\n goto out;\n }\n ret = check_ragged_column(num_rows, metadata, metadata_offset);\n if (ret != 0) {\n goto out;\n }\n\n tsk_mutation_table_free_columns(self);\n self->num_rows = num_rows;\n self->max_rows = num_rows;\n self->site = site;\n self->node = node;\n\n ret = takeset_optional_id_column(num_rows, parent, &self->parent);\n if (ret != 0) {\n goto out;\n }\n if (time == NULL) {\n /* Time defaults to unknown time if not specified. */\n self->time = tsk_malloc(num_rows * sizeof(*self->time));\n if (self->time == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n self->time[j] = TSK_UNKNOWN_TIME;\n }\n\n } else {\n self->time = time;\n }\n\n ret = takeset_ragged_column(num_rows, derived_state, derived_state_offset,\n (void *) &self->derived_state, &self->derived_state_offset,\n &self->derived_state_length);\n if (ret != 0) {\n goto out;\n }\n ret = takeset_ragged_column(num_rows, metadata, metadata_offset,\n (void *) &self->metadata, &self->metadata_offset, &self->metadata_length);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_mutation_table_copy(\n const tsk_mutation_table_t *self, tsk_mutation_table_t *dest, tsk_flags_t options)\n{\n int ret = 0;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_mutation_table_init(dest, 0);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_mutation_table_set_columns(dest, self->num_rows, self->site, self->node,\n self->parent, self->time, self->derived_state, self->derived_state_offset,\n self->metadata, self->metadata_offset);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_mutation_table_set_metadata_schema(\n dest, self->metadata_schema, self->metadata_schema_length);\nout:\n return ret;\n}\n\nint\ntsk_mutation_table_set_columns(tsk_mutation_table_t *self, tsk_size_t num_rows,\n const tsk_id_t *site, const tsk_id_t *node, const tsk_id_t *parent,\n const double *time, const char *derived_state,\n const tsk_size_t *derived_state_offset, const char *metadata,\n const tsk_size_t *metadata_offset)\n{\n int ret = 0;\n\n ret = tsk_mutation_table_clear(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_mutation_table_append_columns(self, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, metadata, metadata_offset);\nout:\n return ret;\n}\n\nbool\ntsk_mutation_table_equals(const tsk_mutation_table_t *self,\n const tsk_mutation_table_t *other, tsk_flags_t options)\n{\n bool ret\n = self->num_rows == other->num_rows\n && self->derived_state_length == other->derived_state_length\n && tsk_memcmp(self->site, other->site, self->num_rows * sizeof(tsk_id_t)) == 0\n && tsk_memcmp(self->node, other->node, self->num_rows * sizeof(tsk_id_t)) == 0\n && tsk_memcmp(self->parent, other->parent, self->num_rows * sizeof(tsk_id_t))\n == 0\n && tsk_memcmp(self->time, other->time, self->num_rows * sizeof(double)) == 0\n && tsk_memcmp(self->derived_state_offset, other->derived_state_offset,\n (self->num_rows + 1) * sizeof(tsk_size_t))\n == 0\n && tsk_memcmp(self->derived_state, other->derived_state,\n self->derived_state_length * sizeof(char))\n == 0;\n if (!(options & TSK_CMP_IGNORE_METADATA)) {\n ret = ret && self->metadata_length == other->metadata_length\n && self->metadata_schema_length == other->metadata_schema_length\n && tsk_memcmp(self->metadata_offset, other->metadata_offset,\n (self->num_rows + 1) * sizeof(tsk_size_t))\n == 0\n && tsk_memcmp(self->metadata, other->metadata,\n self->metadata_length * sizeof(char))\n == 0\n && tsk_memcmp(self->metadata_schema, other->metadata_schema,\n self->metadata_schema_length * sizeof(char))\n == 0\n && tsk_memcmp(self->metadata_schema, other->metadata_schema,\n self->metadata_schema_length * sizeof(char))\n == 0;\n }\n return ret;\n}\n\nint\ntsk_mutation_table_clear(tsk_mutation_table_t *self)\n{\n return tsk_mutation_table_truncate(self, 0);\n}\n\nint\ntsk_mutation_table_truncate(tsk_mutation_table_t *mutations, tsk_size_t num_rows)\n{\n int ret = 0;\n\n if (num_rows > mutations->num_rows) {\n ret = tsk_trace_error(TSK_ERR_BAD_TABLE_POSITION);\n goto out;\n }\n mutations->num_rows = num_rows;\n mutations->derived_state_length = mutations->derived_state_offset[num_rows];\n mutations->metadata_length = mutations->metadata_offset[num_rows];\nout:\n return ret;\n}\n\nint\ntsk_mutation_table_extend(tsk_mutation_table_t *self, const tsk_mutation_table_t *other,\n tsk_size_t num_rows, const tsk_id_t *row_indexes, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_mutation_t mutation;\n\n if (self == other) {\n ret = tsk_trace_error(TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n goto out;\n }\n\n /* We know how much to expand the non-ragged columns, so do it ahead of time */\n ret = tsk_mutation_table_expand_main_columns(self, num_rows);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n ret = tsk_mutation_table_get_row(\n other, row_indexes == NULL ? (tsk_id_t) j : row_indexes[j], &mutation);\n if (ret != 0) {\n goto out;\n }\n ret_id = tsk_mutation_table_add_row(self, mutation.site, mutation.node,\n mutation.parent, mutation.time, mutation.derived_state,\n mutation.derived_state_length, mutation.metadata, mutation.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nvoid\ntsk_mutation_table_print_state(const tsk_mutation_table_t *self, FILE *out)\n{\n int ret;\n\n fprintf(out, \"\\n\" TABLE_SEP);\n fprintf(out, \"mutation_table: %p:\\n\", (const void *) self);\n fprintf(out, \"num_rows = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->num_rows, (long long) self->max_rows,\n (long long) self->max_rows_increment);\n fprintf(out, \"derived_state_length = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->derived_state_length,\n (long long) self->max_derived_state_length,\n (long long) self->max_derived_state_length_increment);\n fprintf(out, \"metadata_length = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->metadata_length, (long long) self->max_metadata_length,\n (long long) self->max_metadata_length_increment);\n fprintf(out, TABLE_SEP);\n ret = tsk_mutation_table_dump_text(self, out);\n tsk_bug_assert(ret == 0);\n tsk_bug_assert(self->derived_state_offset[0] == 0);\n tsk_bug_assert(\n self->derived_state_length == self->derived_state_offset[self->num_rows]);\n tsk_bug_assert(self->metadata_offset[0] == 0);\n tsk_bug_assert(self->metadata_length == self->metadata_offset[self->num_rows]);\n}\n\nstatic inline void\ntsk_mutation_table_get_row_unsafe(\n const tsk_mutation_table_t *self, tsk_id_t index, tsk_mutation_t *row)\n{\n row->id = (tsk_id_t) index;\n row->site = self->site[index];\n row->node = self->node[index];\n row->parent = self->parent[index];\n row->time = self->time[index];\n row->derived_state_length\n = self->derived_state_offset[index + 1] - self->derived_state_offset[index];\n row->derived_state = self->derived_state + self->derived_state_offset[index];\n row->metadata_length\n = self->metadata_offset[index + 1] - self->metadata_offset[index];\n row->metadata = self->metadata + self->metadata_offset[index];\n row->edge = TSK_NULL;\n}\n\nint\ntsk_mutation_table_get_row(\n const tsk_mutation_table_t *self, tsk_id_t index, tsk_mutation_t *row)\n{\n int ret = 0;\n\n if (index < 0 || index >= (tsk_id_t) self->num_rows) {\n ret = tsk_trace_error(TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n goto out;\n }\n tsk_mutation_table_get_row_unsafe(self, index, row);\nout:\n return ret;\n}\n\nint\ntsk_mutation_table_set_metadata_schema(tsk_mutation_table_t *self,\n const char *metadata_schema, tsk_size_t metadata_schema_length)\n{\n return replace_string(&self->metadata_schema, &self->metadata_schema_length,\n metadata_schema, metadata_schema_length);\n}\n\nint\ntsk_mutation_table_dump_text(const tsk_mutation_table_t *self, FILE *out)\n{\n int ret = TSK_ERR_IO;\n int err;\n tsk_size_t j, derived_state_len, metadata_len;\n\n err = write_metadata_schema_header(\n out, self->metadata_schema, self->metadata_schema_length);\n if (err < 0) {\n goto out;\n }\n err = fprintf(out, \"id\\tsite\\tnode\\tparent\\ttime\\tderived_state\\tmetadata\\n\");\n if (err < 0) {\n goto out;\n }\n for (j = 0; j < self->num_rows; j++) {\n derived_state_len\n = self->derived_state_offset[j + 1] - self->derived_state_offset[j];\n metadata_len = self->metadata_offset[j + 1] - self->metadata_offset[j];\n err = fprintf(out, \"%lld\\t%lld\\t%lld\\t%lld\\t%f\\t%.*s\\t%.*s\\n\", (long long) j,\n (long long) self->site[j], (long long) self->node[j],\n (long long) self->parent[j], self->time[j], (int) derived_state_len,\n self->derived_state + self->derived_state_offset[j], (int) metadata_len,\n self->metadata + self->metadata_offset[j]);\n if (err < 0) {\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nint\ntsk_mutation_table_keep_rows(tsk_mutation_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t TSK_UNUSED(options), tsk_id_t *ret_id_map)\n{\n int ret = 0;\n const tsk_size_t current_num_rows = self->num_rows;\n tsk_size_t j, remaining_rows;\n tsk_id_t pj;\n tsk_id_t *id_map = ret_id_map;\n tsk_id_t *restrict parent = self->parent;\n\n if (ret_id_map == NULL) {\n id_map = tsk_malloc(current_num_rows * sizeof(*id_map));\n if (id_map == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n }\n\n keep_mask_to_id_map(current_num_rows, keep, id_map);\n\n /* Note: we could add some options to avoid these checks if we wanted.\n * MAP_DELETED_TO_NULL is an obvious one, and I guess it might be\n * helpful to also provide NO_REMAP to prevent reference remapping\n * entirely. */\n for (j = 0; j < current_num_rows; j++) {\n if (keep[j]) {\n pj = parent[j];\n if (pj != TSK_NULL) {\n if (pj < 0 || pj >= (tsk_id_t) current_num_rows) {\n ret = tsk_trace_error(TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n goto out;\n }\n if (id_map[pj] == TSK_NULL) {\n ret = tsk_trace_error(TSK_ERR_KEEP_ROWS_MAP_TO_DELETED);\n goto out;\n }\n }\n }\n }\n\n remaining_rows = subset_id_column(self->site, current_num_rows, keep);\n subset_id_column(self->node, current_num_rows, keep);\n subset_remap_id_column(parent, current_num_rows, keep, id_map);\n subset_double_column(self->time, current_num_rows, keep);\n self->derived_state_length = subset_ragged_char_column(\n self->derived_state, self->derived_state_offset, current_num_rows, keep);\n if (self->metadata_length > 0) {\n self->metadata_length = subset_ragged_char_column(\n self->metadata, self->metadata_offset, current_num_rows, keep);\n }\n self->num_rows = remaining_rows;\nout:\n if (ret_id_map == NULL) {\n tsk_safe_free(id_map);\n }\n return ret;\n}\n\nstatic int\ntsk_mutation_table_dump(\n const tsk_mutation_table_t *self, kastore_t *store, tsk_flags_t options)\n{\n const write_table_col_t cols[] = {\n { \"mutations/site\", (void *) self->site, self->num_rows, TSK_ID_STORAGE_TYPE },\n { \"mutations/node\", (void *) self->node, self->num_rows, TSK_ID_STORAGE_TYPE },\n { \"mutations/parent\", (void *) self->parent, self->num_rows,\n TSK_ID_STORAGE_TYPE },\n { \"mutations/time\", (void *) self->time, self->num_rows, KAS_FLOAT64 },\n { \"mutations/metadata_schema\", (void *) self->metadata_schema,\n self->metadata_schema_length, KAS_UINT8 },\n { .name = NULL },\n };\n const write_table_ragged_col_t ragged_cols[] = {\n { \"mutations/derived_state\", (void *) self->derived_state,\n self->derived_state_length, KAS_UINT8, self->derived_state_offset,\n self->num_rows },\n { \"mutations/metadata\", (void *) self->metadata, self->metadata_length,\n KAS_UINT8, self->metadata_offset, self->num_rows },\n { .name = NULL },\n };\n\n return write_table(store, cols, ragged_cols, options);\n}\n\nstatic int\ntsk_mutation_table_load(tsk_mutation_table_t *self, kastore_t *store)\n{\n int ret = 0;\n tsk_id_t *node = NULL;\n tsk_id_t *site = NULL;\n tsk_id_t *parent = NULL;\n double *time = NULL;\n char *derived_state = NULL;\n tsk_size_t *derived_state_offset = NULL;\n char *metadata = NULL;\n tsk_size_t *metadata_offset = NULL;\n char *metadata_schema = NULL;\n tsk_size_t num_rows, derived_state_length, metadata_length, metadata_schema_length;\n\n read_table_col_t cols[] = {\n { \"mutations/site\", (void **) &site, TSK_ID_STORAGE_TYPE, 0 },\n { \"mutations/node\", (void **) &node, TSK_ID_STORAGE_TYPE, 0 },\n { \"mutations/parent\", (void **) &parent, TSK_ID_STORAGE_TYPE, 0 },\n { \"mutations/time\", (void **) &time, KAS_FLOAT64, TSK_COL_OPTIONAL },\n { .name = NULL },\n };\n read_table_ragged_col_t ragged_cols[] = {\n { \"mutations/derived_state\", (void **) &derived_state, &derived_state_length,\n KAS_UINT8, &derived_state_offset, 0 },\n { \"mutations/metadata\", (void **) &metadata, &metadata_length, KAS_UINT8,\n &metadata_offset, 0 },\n { .name = NULL },\n };\n read_table_property_t properties[] = {\n { \"mutations/metadata_schema\", (void **) &metadata_schema,\n &metadata_schema_length, KAS_UINT8, TSK_COL_OPTIONAL },\n { .name = NULL },\n };\n\n ret = read_table(store, &num_rows, cols, ragged_cols, properties, 0);\n if (ret != 0) {\n goto out;\n }\n if (metadata_schema != NULL) {\n ret = tsk_mutation_table_set_metadata_schema(\n self, metadata_schema, metadata_schema_length);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_mutation_table_takeset_columns(self, num_rows, site, node, parent, time,\n derived_state, derived_state_offset, metadata, metadata_offset);\n if (ret != 0) {\n goto out;\n }\n site = NULL;\n node = NULL;\n parent = NULL;\n time = NULL;\n derived_state = NULL;\n derived_state_offset = NULL;\n metadata = NULL;\n metadata_offset = NULL;\n\nout:\n free_read_table_mem(cols, ragged_cols, properties);\n return ret;\n}\n\n/*************************\n * migration table\n *************************/\n\nstatic void\ntsk_migration_table_free_columns(tsk_migration_table_t *self)\n{\n tsk_safe_free(self->left);\n tsk_safe_free(self->right);\n tsk_safe_free(self->node);\n tsk_safe_free(self->source);\n tsk_safe_free(self->dest);\n tsk_safe_free(self->time);\n tsk_safe_free(self->metadata);\n tsk_safe_free(self->metadata_offset);\n}\n\nint\ntsk_migration_table_free(tsk_migration_table_t *self)\n{\n tsk_migration_table_free_columns(self);\n tsk_safe_free(self->metadata_schema);\n return 0;\n}\n\nstatic int\ntsk_migration_table_expand_main_columns(\n tsk_migration_table_t *self, tsk_size_t additional_rows)\n{\n int ret = 0;\n tsk_size_t new_max_rows;\n\n ret = calculate_max_rows(self->num_rows, self->max_rows, self->max_rows_increment,\n additional_rows, &new_max_rows);\n if (ret != 0) {\n goto out;\n }\n if ((self->num_rows + additional_rows) > self->max_rows) {\n ret = expand_column((void **) &self->left, new_max_rows, sizeof(double));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column((void **) &self->right, new_max_rows, sizeof(double));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column((void **) &self->node, new_max_rows, sizeof(tsk_id_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column((void **) &self->source, new_max_rows, sizeof(tsk_id_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column((void **) &self->dest, new_max_rows, sizeof(tsk_id_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column((void **) &self->time, new_max_rows, sizeof(double));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column(\n (void **) &self->metadata_offset, new_max_rows + 1, sizeof(tsk_size_t));\n if (ret != 0) {\n goto out;\n }\n\n self->max_rows = new_max_rows;\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_migration_table_expand_metadata(\n tsk_migration_table_t *self, tsk_size_t additional_length)\n{\n return expand_ragged_column(self->metadata_length, additional_length,\n self->max_metadata_length_increment, &self->max_metadata_length,\n (void **) &self->metadata, sizeof(*self->metadata));\n}\n\nint\ntsk_migration_table_set_max_rows_increment(\n tsk_migration_table_t *self, tsk_size_t max_rows_increment)\n{\n self->max_rows_increment = max_rows_increment;\n return 0;\n}\n\nint\ntsk_migration_table_set_max_metadata_length_increment(\n tsk_migration_table_t *self, tsk_size_t max_metadata_length_increment)\n{\n self->max_metadata_length_increment = max_metadata_length_increment;\n return 0;\n}\n\nint\ntsk_migration_table_init(tsk_migration_table_t *self, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n\n tsk_memset(self, 0, sizeof(tsk_migration_table_t));\n\n /* Allocate space for one row initially, ensuring we always have valid pointers\n * even if the table is empty */\n self->max_rows_increment = 1;\n self->max_metadata_length_increment = 1;\n ret = tsk_migration_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_migration_table_expand_metadata(self, 1);\n if (ret != 0) {\n goto out;\n }\n self->metadata_offset[0] = 0;\n self->max_rows_increment = 0;\n self->max_metadata_length_increment = 0;\n tsk_migration_table_set_metadata_schema(self, NULL, 0);\nout:\n return ret;\n}\n\nint\ntsk_migration_table_append_columns(tsk_migration_table_t *self, tsk_size_t num_rows,\n const double *left, const double *right, const tsk_id_t *node,\n const tsk_id_t *source, const tsk_id_t *dest, const double *time,\n const char *metadata, const tsk_size_t *metadata_offset)\n{\n int ret;\n tsk_size_t j, metadata_length;\n\n if (left == NULL || right == NULL || node == NULL || source == NULL || dest == NULL\n || time == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if ((metadata == NULL) != (metadata_offset == NULL)) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n\n ret = tsk_migration_table_expand_main_columns(self, num_rows);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->left + self->num_rows, left, num_rows * sizeof(double));\n tsk_memcpy(self->right + self->num_rows, right, num_rows * sizeof(double));\n tsk_memcpy(self->node + self->num_rows, node, num_rows * sizeof(tsk_id_t));\n tsk_memcpy(self->source + self->num_rows, source, num_rows * sizeof(tsk_id_t));\n tsk_memcpy(self->dest + self->num_rows, dest, num_rows * sizeof(tsk_id_t));\n tsk_memcpy(self->time + self->num_rows, time, num_rows * sizeof(double));\n if (metadata == NULL) {\n for (j = 0; j < num_rows; j++) {\n self->metadata_offset[self->num_rows + j + 1] = self->metadata_length;\n }\n } else {\n ret = check_offsets(num_rows, metadata_offset, 0, false);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n self->metadata_offset[self->num_rows + j]\n = (tsk_size_t) self->metadata_length + metadata_offset[j];\n }\n metadata_length = metadata_offset[num_rows];\n ret = tsk_migration_table_expand_metadata(self, metadata_length);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->metadata + self->metadata_length, metadata,\n metadata_length * sizeof(char));\n self->metadata_length += metadata_length;\n }\n\n self->num_rows += num_rows;\n self->metadata_offset[self->num_rows] = self->metadata_length;\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_migration_table_takeset_columns(tsk_migration_table_t *self, tsk_size_t num_rows,\n double *left, double *right, tsk_id_t *node, tsk_id_t *source, tsk_id_t *dest,\n double *time, char *metadata, tsk_size_t *metadata_offset)\n{\n int ret = 0;\n\n if (left == NULL || right == NULL || node == NULL || source == NULL || dest == NULL\n || time == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n\n /* We need to check all the inputs before we start freeing or taking memory */\n ret = check_ragged_column(num_rows, metadata, metadata_offset);\n if (ret != 0) {\n goto out;\n }\n\n tsk_migration_table_free_columns(self);\n self->num_rows = num_rows;\n self->max_rows = num_rows;\n self->left = left;\n self->right = right;\n self->node = node;\n self->source = source;\n self->dest = dest;\n self->time = time;\n\n ret = takeset_ragged_column(num_rows, metadata, metadata_offset,\n (void *) &self->metadata, &self->metadata_offset, &self->metadata_length);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_migration_table_copy(\n const tsk_migration_table_t *self, tsk_migration_table_t *dest, tsk_flags_t options)\n{\n int ret = 0;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_migration_table_init(dest, 0);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_migration_table_set_columns(dest, self->num_rows, self->left, self->right,\n self->node, self->source, self->dest, self->time, self->metadata,\n self->metadata_offset);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_migration_table_set_metadata_schema(\n dest, self->metadata_schema, self->metadata_schema_length);\nout:\n return ret;\n}\n\nint\ntsk_migration_table_set_columns(tsk_migration_table_t *self, tsk_size_t num_rows,\n const double *left, const double *right, const tsk_id_t *node,\n const tsk_id_t *source, const tsk_id_t *dest, const double *time,\n const char *metadata, const tsk_size_t *metadata_offset)\n{\n int ret;\n\n ret = tsk_migration_table_clear(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_migration_table_append_columns(self, num_rows, left, right, node, source,\n dest, time, metadata, metadata_offset);\nout:\n return ret;\n}\n\ntsk_id_t\ntsk_migration_table_add_row(tsk_migration_table_t *self, double left, double right,\n tsk_id_t node, tsk_id_t source, tsk_id_t dest, double time, const char *metadata,\n tsk_size_t metadata_length)\n{\n tsk_id_t ret = 0;\n\n ret = tsk_migration_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_migration_table_expand_metadata(self, metadata_length);\n if (ret != 0) {\n goto out;\n }\n\n tsk_bug_assert(self->num_rows < self->max_rows);\n tsk_bug_assert(self->metadata_length + metadata_length <= self->max_metadata_length);\n tsk_memmove(self->metadata + self->metadata_length, metadata, metadata_length);\n self->left[self->num_rows] = left;\n self->right[self->num_rows] = right;\n self->node[self->num_rows] = node;\n self->source[self->num_rows] = source;\n self->dest[self->num_rows] = dest;\n self->time[self->num_rows] = time;\n self->metadata_offset[self->num_rows + 1] = self->metadata_length + metadata_length;\n self->metadata_length += metadata_length;\n\n ret = (tsk_id_t) self->num_rows;\n self->num_rows++;\nout:\n return ret;\n}\n\nstatic int\ntsk_migration_table_update_row_rewrite(tsk_migration_table_t *self, tsk_id_t index,\n double left, double right, tsk_id_t node, tsk_id_t source, tsk_id_t dest,\n double time, const char *metadata, tsk_size_t metadata_length)\n{\n int ret = 0;\n tsk_id_t j, ret_id;\n tsk_migration_table_t copy;\n tsk_size_t num_rows;\n tsk_id_t *rows = NULL;\n\n ret = tsk_migration_table_copy(self, ©, 0);\n if (ret != 0) {\n goto out;\n }\n rows = tsk_malloc(self->num_rows * sizeof(*rows));\n if (rows == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n ret = tsk_migration_table_truncate(self, (tsk_size_t) index);\n tsk_bug_assert(ret == 0);\n ret_id = tsk_migration_table_add_row(\n self, left, right, node, source, dest, time, metadata, metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n num_rows = 0;\n for (j = index + 1; j < (tsk_id_t) copy.num_rows; j++) {\n rows[num_rows] = j;\n num_rows++;\n }\n ret = tsk_migration_table_extend(self, ©, num_rows, rows, 0);\n if (ret != 0) {\n goto out;\n }\nout:\n tsk_migration_table_free(©);\n tsk_safe_free(rows);\n return ret;\n}\n\nint\ntsk_migration_table_update_row(tsk_migration_table_t *self, tsk_id_t index, double left,\n double right, tsk_id_t node, tsk_id_t source, tsk_id_t dest, double time,\n const char *metadata, tsk_size_t metadata_length)\n{\n int ret = 0;\n tsk_migration_t current_row;\n\n ret = tsk_migration_table_get_row(self, index, ¤t_row);\n if (ret != 0) {\n goto out;\n }\n if (current_row.metadata_length == metadata_length) {\n self->left[index] = left;\n self->right[index] = right;\n self->node[index] = node;\n self->source[index] = source;\n self->dest[index] = dest;\n self->time[index] = time;\n /* Note: important to use tsk_memmove here as we may be provided pointers\n * to the column memory as input via get_row */\n tsk_memmove(&self->metadata[self->metadata_offset[index]], metadata,\n metadata_length * sizeof(*metadata));\n } else {\n ret = tsk_migration_table_update_row_rewrite(self, index, left, right, node,\n source, dest, time, metadata, metadata_length);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nint\ntsk_migration_table_clear(tsk_migration_table_t *self)\n{\n return tsk_migration_table_truncate(self, 0);\n}\n\nint\ntsk_migration_table_truncate(tsk_migration_table_t *self, tsk_size_t num_rows)\n{\n int ret = 0;\n\n if (num_rows > self->num_rows) {\n ret = tsk_trace_error(TSK_ERR_BAD_TABLE_POSITION);\n goto out;\n }\n self->num_rows = num_rows;\n self->metadata_length = self->metadata_offset[num_rows];\nout:\n return ret;\n}\n\nint\ntsk_migration_table_extend(tsk_migration_table_t *self,\n const tsk_migration_table_t *other, tsk_size_t num_rows, const tsk_id_t *row_indexes,\n tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_migration_t migration;\n\n if (self == other) {\n ret = tsk_trace_error(TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n goto out;\n }\n\n /* We know how much to expand the non-ragged columns, so do it ahead of time */\n ret = tsk_migration_table_expand_main_columns(self, num_rows);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n ret = tsk_migration_table_get_row(\n other, row_indexes == NULL ? (tsk_id_t) j : row_indexes[j], &migration);\n if (ret != 0) {\n goto out;\n }\n ret_id = tsk_migration_table_add_row(self, migration.left, migration.right,\n migration.node, migration.source, migration.dest, migration.time,\n migration.metadata, migration.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nvoid\ntsk_migration_table_print_state(const tsk_migration_table_t *self, FILE *out)\n{\n int ret;\n\n fprintf(out, \"\\n\" TABLE_SEP);\n fprintf(out, \"migration_table: %p:\\n\", (const void *) self);\n fprintf(out, \"num_rows = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->num_rows, (long long) self->max_rows,\n (long long) self->max_rows_increment);\n fprintf(out, \"metadata_length = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->metadata_length, (long long) self->max_metadata_length,\n (long long) self->max_metadata_length_increment);\n fprintf(out, TABLE_SEP);\n ret = tsk_migration_table_dump_text(self, out);\n tsk_bug_assert(ret == 0);\n}\n\nstatic inline void\ntsk_migration_table_get_row_unsafe(\n const tsk_migration_table_t *self, tsk_id_t index, tsk_migration_t *row)\n{\n row->id = (tsk_id_t) index;\n row->left = self->left[index];\n row->right = self->right[index];\n row->node = self->node[index];\n row->source = self->source[index];\n row->dest = self->dest[index];\n row->time = self->time[index];\n row->metadata_length\n = self->metadata_offset[index + 1] - self->metadata_offset[index];\n row->metadata = self->metadata + self->metadata_offset[index];\n}\n\nint\ntsk_migration_table_get_row(\n const tsk_migration_table_t *self, tsk_id_t index, tsk_migration_t *row)\n{\n int ret = 0;\n\n if (index < 0 || index >= (tsk_id_t) self->num_rows) {\n ret = tsk_trace_error(TSK_ERR_MIGRATION_OUT_OF_BOUNDS);\n goto out;\n }\n tsk_migration_table_get_row_unsafe(self, index, row);\nout:\n return ret;\n}\n\nint\ntsk_migration_table_set_metadata_schema(tsk_migration_table_t *self,\n const char *metadata_schema, tsk_size_t metadata_schema_length)\n{\n return replace_string(&self->metadata_schema, &self->metadata_schema_length,\n metadata_schema, metadata_schema_length);\n}\n\nint\ntsk_migration_table_dump_text(const tsk_migration_table_t *self, FILE *out)\n{\n tsk_size_t j;\n int ret = TSK_ERR_IO;\n tsk_size_t metadata_len;\n int err;\n\n err = write_metadata_schema_header(\n out, self->metadata_schema, self->metadata_schema_length);\n if (err < 0) {\n goto out;\n }\n err = fprintf(out, \"left\\tright\\tnode\\tsource\\tdest\\ttime\\tmetadata\\n\");\n if (err < 0) {\n goto out;\n }\n for (j = 0; j < self->num_rows; j++) {\n metadata_len = self->metadata_offset[j + 1] - self->metadata_offset[j];\n err = fprintf(out, \"%.3f\\t%.3f\\t%lld\\t%lld\\t%lld\\t%f\\t%.*s\\n\", self->left[j],\n self->right[j], (long long) self->node[j], (long long) self->source[j],\n (long long) self->dest[j], self->time[j], (int) metadata_len,\n self->metadata + self->metadata_offset[j]);\n if (err < 0) {\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nbool\ntsk_migration_table_equals(const tsk_migration_table_t *self,\n const tsk_migration_table_t *other, tsk_flags_t options)\n{\n bool ret\n = self->num_rows == other->num_rows\n && tsk_memcmp(self->left, other->left, self->num_rows * sizeof(double)) == 0\n && tsk_memcmp(self->right, other->right, self->num_rows * sizeof(double)) == 0\n && tsk_memcmp(self->node, other->node, self->num_rows * sizeof(tsk_id_t)) == 0\n && tsk_memcmp(self->source, other->source, self->num_rows * sizeof(tsk_id_t))\n == 0\n && tsk_memcmp(self->dest, other->dest, self->num_rows * sizeof(tsk_id_t)) == 0\n && tsk_memcmp(self->time, other->time, self->num_rows * sizeof(double)) == 0;\n if (!(options & TSK_CMP_IGNORE_METADATA)) {\n ret = ret && self->metadata_length == other->metadata_length\n && self->metadata_schema_length == other->metadata_schema_length\n && tsk_memcmp(self->metadata_offset, other->metadata_offset,\n (self->num_rows + 1) * sizeof(tsk_size_t))\n == 0\n && tsk_memcmp(self->metadata, other->metadata,\n self->metadata_length * sizeof(char))\n == 0\n && tsk_memcmp(self->metadata_schema, other->metadata_schema,\n self->metadata_schema_length * sizeof(char))\n == 0;\n }\n return ret;\n}\n\nint\ntsk_migration_table_keep_rows(tsk_migration_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t TSK_UNUSED(options), tsk_id_t *id_map)\n{\n int ret = 0;\n tsk_size_t remaining_rows;\n\n if (id_map != NULL) {\n keep_mask_to_id_map(self->num_rows, keep, id_map);\n }\n\n remaining_rows = subset_double_column(self->left, self->num_rows, keep);\n subset_double_column(self->right, self->num_rows, keep);\n subset_id_column(self->node, self->num_rows, keep);\n subset_id_column(self->source, self->num_rows, keep);\n subset_id_column(self->dest, self->num_rows, keep);\n subset_double_column(self->time, self->num_rows, keep);\n if (self->metadata_length > 0) {\n self->metadata_length = subset_ragged_char_column(\n self->metadata, self->metadata_offset, self->num_rows, keep);\n }\n self->num_rows = remaining_rows;\n return ret;\n}\n\nstatic int\ntsk_migration_table_dump(\n const tsk_migration_table_t *self, kastore_t *store, tsk_flags_t options)\n{\n const write_table_col_t cols[] = {\n { \"migrations/left\", (void *) self->left, self->num_rows, KAS_FLOAT64 },\n { \"migrations/right\", (void *) self->right, self->num_rows, KAS_FLOAT64 },\n { \"migrations/node\", (void *) self->node, self->num_rows, TSK_ID_STORAGE_TYPE },\n { \"migrations/source\", (void *) self->source, self->num_rows,\n TSK_ID_STORAGE_TYPE },\n { \"migrations/dest\", (void *) self->dest, self->num_rows, TSK_ID_STORAGE_TYPE },\n { \"migrations/time\", (void *) self->time, self->num_rows, KAS_FLOAT64 },\n { \"migrations/metadata_schema\", (void *) self->metadata_schema,\n self->metadata_schema_length, KAS_UINT8 },\n { .name = NULL },\n };\n const write_table_ragged_col_t ragged_cols[] = {\n { \"migrations/metadata\", (void *) self->metadata, self->metadata_length,\n KAS_UINT8, self->metadata_offset, self->num_rows },\n { .name = NULL },\n };\n\n return write_table(store, cols, ragged_cols, options);\n}\n\nstatic int\ntsk_migration_table_load(tsk_migration_table_t *self, kastore_t *store)\n{\n int ret = 0;\n tsk_id_t *source = NULL;\n tsk_id_t *dest = NULL;\n tsk_id_t *node = NULL;\n double *left = NULL;\n double *right = NULL;\n double *time = NULL;\n char *metadata = NULL;\n tsk_size_t *metadata_offset = NULL;\n char *metadata_schema = NULL;\n tsk_size_t num_rows, metadata_length, metadata_schema_length;\n\n read_table_col_t cols[] = {\n { \"migrations/left\", (void **) &left, KAS_FLOAT64, 0 },\n { \"migrations/right\", (void **) &right, KAS_FLOAT64, 0 },\n { \"migrations/node\", (void **) &node, TSK_ID_STORAGE_TYPE, 0 },\n { \"migrations/source\", (void **) &source, TSK_ID_STORAGE_TYPE, 0 },\n { \"migrations/dest\", (void **) &dest, TSK_ID_STORAGE_TYPE, 0 },\n { \"migrations/time\", (void **) &time, KAS_FLOAT64, 0 },\n { .name = NULL },\n };\n read_table_ragged_col_t ragged_cols[] = {\n { \"migrations/metadata\", (void **) &metadata, &metadata_length, KAS_UINT8,\n &metadata_offset, TSK_COL_OPTIONAL },\n { .name = NULL },\n };\n read_table_property_t properties[] = {\n { \"migrations/metadata_schema\", (void **) &metadata_schema,\n &metadata_schema_length, KAS_UINT8, TSK_COL_OPTIONAL },\n { .name = NULL },\n };\n\n ret = read_table(store, &num_rows, cols, ragged_cols, properties, 0);\n if (ret != 0) {\n goto out;\n }\n if (metadata_schema != NULL) {\n ret = tsk_migration_table_set_metadata_schema(\n self, metadata_schema, metadata_schema_length);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_migration_table_takeset_columns(self, num_rows, left, right, node, source,\n dest, time, metadata, metadata_offset);\n if (ret != 0) {\n goto out;\n }\n left = NULL;\n right = NULL;\n node = NULL;\n source = NULL;\n dest = NULL;\n time = NULL;\n metadata = NULL;\n metadata_offset = NULL;\n\nout:\n free_read_table_mem(cols, ragged_cols, properties);\n return ret;\n}\n\n/*************************\n * population table\n *************************/\n\nstatic void\ntsk_population_table_free_columns(tsk_population_table_t *self)\n{\n tsk_safe_free(self->metadata);\n tsk_safe_free(self->metadata_offset);\n}\n\nint\ntsk_population_table_free(tsk_population_table_t *self)\n{\n tsk_population_table_free_columns(self);\n tsk_safe_free(self->metadata_schema);\n return 0;\n}\n\nstatic int\ntsk_population_table_expand_main_columns(\n tsk_population_table_t *self, tsk_size_t additional_rows)\n{\n int ret = 0;\n tsk_size_t new_max_rows;\n\n ret = calculate_max_rows(self->num_rows, self->max_rows, self->max_rows_increment,\n additional_rows, &new_max_rows);\n if (ret != 0) {\n goto out;\n }\n if ((self->num_rows + additional_rows) > self->max_rows) {\n ret = expand_column(\n (void **) &self->metadata_offset, new_max_rows + 1, sizeof(tsk_size_t));\n if (ret != 0) {\n goto out;\n }\n self->max_rows = new_max_rows;\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_population_table_expand_metadata(\n tsk_population_table_t *self, tsk_size_t additional_length)\n{\n return expand_ragged_column(self->metadata_length, additional_length,\n self->max_metadata_length_increment, &self->max_metadata_length,\n (void **) &self->metadata, sizeof(*self->metadata));\n}\n\nint\ntsk_population_table_set_max_rows_increment(\n tsk_population_table_t *self, tsk_size_t max_rows_increment)\n{\n self->max_rows_increment = max_rows_increment;\n return 0;\n}\n\nint\ntsk_population_table_set_max_metadata_length_increment(\n tsk_population_table_t *self, tsk_size_t max_metadata_length_increment)\n{\n self->max_metadata_length_increment = max_metadata_length_increment;\n return 0;\n}\n\nint\ntsk_population_table_init(tsk_population_table_t *self, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n\n tsk_memset(self, 0, sizeof(tsk_population_table_t));\n /* Allocate space for one row initially, ensuring we always have valid pointers\n * even if the table is empty */\n self->max_rows_increment = 1;\n self->max_metadata_length_increment = 1;\n ret = tsk_population_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_population_table_expand_metadata(self, 1);\n if (ret != 0) {\n goto out;\n }\n self->metadata_offset[0] = 0;\n self->max_rows_increment = 0;\n self->max_metadata_length_increment = 0;\n tsk_population_table_set_metadata_schema(self, NULL, 0);\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_population_table_copy(const tsk_population_table_t *self,\n tsk_population_table_t *dest, tsk_flags_t options)\n{\n int ret = 0;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_population_table_init(dest, 0);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_population_table_set_columns(\n dest, self->num_rows, self->metadata, self->metadata_offset);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_population_table_set_metadata_schema(\n dest, self->metadata_schema, self->metadata_schema_length);\nout:\n return ret;\n}\n\nint\ntsk_population_table_set_columns(tsk_population_table_t *self, tsk_size_t num_rows,\n const char *metadata, const tsk_size_t *metadata_offset)\n{\n int ret;\n\n ret = tsk_population_table_clear(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_population_table_append_columns(self, num_rows, metadata, metadata_offset);\nout:\n return ret;\n}\n\nint\ntsk_population_table_append_columns(tsk_population_table_t *self, tsk_size_t num_rows,\n const char *metadata, const tsk_size_t *metadata_offset)\n{\n int ret;\n tsk_size_t j, metadata_length;\n\n if (metadata == NULL || metadata_offset == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n ret = tsk_population_table_expand_main_columns(self, num_rows);\n if (ret != 0) {\n goto out;\n }\n\n ret = check_offsets(num_rows, metadata_offset, 0, false);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n self->metadata_offset[self->num_rows + j]\n = self->metadata_length + metadata_offset[j];\n }\n metadata_length = metadata_offset[num_rows];\n ret = tsk_population_table_expand_metadata(self, metadata_length);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->metadata + self->metadata_length, metadata,\n metadata_length * sizeof(char));\n self->metadata_length += metadata_length;\n\n self->num_rows += num_rows;\n self->metadata_offset[self->num_rows] = self->metadata_length;\nout:\n return ret;\n}\n\nint\ntsk_population_table_takeset_columns(tsk_population_table_t *self, tsk_size_t num_rows,\n char *metadata, tsk_size_t *metadata_offset)\n{\n int ret = 0;\n\n /* We need to check all the inputs before we start freeing or taking memory */\n if (metadata == NULL || metadata_offset == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n ret = check_ragged_column(num_rows, metadata, metadata_offset);\n if (ret != 0) {\n goto out;\n }\n\n tsk_population_table_free_columns(self);\n self->num_rows = num_rows;\n self->max_rows = num_rows;\n\n ret = takeset_ragged_column(num_rows, metadata, metadata_offset,\n (void *) &self->metadata, &self->metadata_offset, &self->metadata_length);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nstatic tsk_id_t\ntsk_population_table_add_row_internal(\n tsk_population_table_t *self, const char *metadata, tsk_size_t metadata_length)\n{\n tsk_id_t ret = 0;\n\n tsk_bug_assert(self->num_rows < self->max_rows);\n tsk_bug_assert(self->metadata_length + metadata_length <= self->max_metadata_length);\n tsk_memmove(self->metadata + self->metadata_length, metadata, metadata_length);\n self->metadata_offset[self->num_rows + 1] = self->metadata_length + metadata_length;\n self->metadata_length += metadata_length;\n ret = (tsk_id_t) self->num_rows;\n self->num_rows++;\n return ret;\n}\n\ntsk_id_t\ntsk_population_table_add_row(\n tsk_population_table_t *self, const char *metadata, tsk_size_t metadata_length)\n{\n tsk_id_t ret = 0;\n\n ret = tsk_population_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_population_table_expand_metadata(self, metadata_length);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_population_table_add_row_internal(self, metadata, metadata_length);\nout:\n return ret;\n}\n\nstatic int\ntsk_population_table_update_row_rewrite(tsk_population_table_t *self, tsk_id_t index,\n const char *metadata, tsk_size_t metadata_length)\n{\n int ret = 0;\n tsk_id_t j, ret_id;\n tsk_population_table_t copy;\n tsk_size_t num_rows;\n tsk_id_t *rows = NULL;\n\n ret = tsk_population_table_copy(self, ©, 0);\n if (ret != 0) {\n goto out;\n }\n rows = tsk_malloc(self->num_rows * sizeof(*rows));\n if (rows == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n ret = tsk_population_table_truncate(self, (tsk_size_t) index);\n tsk_bug_assert(ret == 0);\n ret_id = tsk_population_table_add_row(self, metadata, metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n num_rows = 0;\n for (j = index + 1; j < (tsk_id_t) copy.num_rows; j++) {\n rows[num_rows] = j;\n num_rows++;\n }\n ret = tsk_population_table_extend(self, ©, num_rows, rows, 0);\n if (ret != 0) {\n goto out;\n }\nout:\n tsk_population_table_free(©);\n tsk_safe_free(rows);\n return ret;\n}\n\nint\ntsk_population_table_update_row(tsk_population_table_t *self, tsk_id_t index,\n const char *metadata, tsk_size_t metadata_length)\n{\n int ret = 0;\n tsk_population_t current_row;\n\n ret = tsk_population_table_get_row(self, index, ¤t_row);\n if (ret != 0) {\n goto out;\n }\n if (current_row.metadata_length == metadata_length) {\n /* Note: important to use tsk_memmove here as we may be provided pointers\n * to the column memory as input via get_row */\n tsk_memmove(&self->metadata[self->metadata_offset[index]], metadata,\n metadata_length * sizeof(*metadata));\n } else {\n ret = tsk_population_table_update_row_rewrite(\n self, index, metadata, metadata_length);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nint\ntsk_population_table_clear(tsk_population_table_t *self)\n{\n return tsk_population_table_truncate(self, 0);\n}\n\nint\ntsk_population_table_truncate(tsk_population_table_t *self, tsk_size_t num_rows)\n{\n int ret = 0;\n\n if (num_rows > self->num_rows) {\n ret = tsk_trace_error(TSK_ERR_BAD_TABLE_POSITION);\n goto out;\n }\n self->num_rows = num_rows;\n self->metadata_length = self->metadata_offset[num_rows];\nout:\n return ret;\n}\n\nint\ntsk_population_table_extend(tsk_population_table_t *self,\n const tsk_population_table_t *other, tsk_size_t num_rows,\n const tsk_id_t *row_indexes, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_population_t population;\n\n if (self == other) {\n ret = tsk_trace_error(TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n goto out;\n }\n\n /* We know how much to expand the non-ragged columns, so do it ahead of time */\n ret = tsk_population_table_expand_main_columns(self, num_rows);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n ret = tsk_population_table_get_row(\n other, row_indexes == NULL ? (tsk_id_t) j : row_indexes[j], &population);\n if (ret != 0) {\n goto out;\n }\n ret_id = tsk_population_table_add_row(\n self, population.metadata, population.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nvoid\ntsk_population_table_print_state(const tsk_population_table_t *self, FILE *out)\n{\n tsk_size_t j, k;\n\n fprintf(out, \"\\n\" TABLE_SEP);\n fprintf(out, \"population_table: %p:\\n\", (const void *) self);\n fprintf(out, \"num_rows = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->num_rows, (long long) self->max_rows,\n (long long) self->max_rows_increment);\n fprintf(out, \"metadata_length = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->metadata_length, (long long) self->max_metadata_length,\n (long long) self->max_metadata_length_increment);\n fprintf(out, TABLE_SEP);\n write_metadata_schema_header(\n out, self->metadata_schema, self->metadata_schema_length);\n fprintf(out, \"index\\tmetadata_offset\\tmetadata\\n\");\n for (j = 0; j < self->num_rows; j++) {\n fprintf(\n out, \"%lld\\t%lld\\t\", (long long) j, (long long) self->metadata_offset[j]);\n for (k = self->metadata_offset[j]; k < self->metadata_offset[j + 1]; k++) {\n fprintf(out, \"%c\", self->metadata[k]);\n }\n fprintf(out, \"\\n\");\n }\n tsk_bug_assert(self->metadata_offset[0] == 0);\n tsk_bug_assert(self->metadata_offset[self->num_rows] == self->metadata_length);\n}\n\nstatic inline void\ntsk_population_table_get_row_unsafe(\n const tsk_population_table_t *self, tsk_id_t index, tsk_population_t *row)\n{\n row->id = (tsk_id_t) index;\n row->metadata_length\n = self->metadata_offset[index + 1] - self->metadata_offset[index];\n row->metadata = self->metadata + self->metadata_offset[index];\n}\n\nint\ntsk_population_table_get_row(\n const tsk_population_table_t *self, tsk_id_t index, tsk_population_t *row)\n{\n int ret = 0;\n\n if (index < 0 || index >= (tsk_id_t) self->num_rows) {\n ret = tsk_trace_error(TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n goto out;\n }\n tsk_population_table_get_row_unsafe(self, index, row);\nout:\n return ret;\n}\n\nint\ntsk_population_table_set_metadata_schema(tsk_population_table_t *self,\n const char *metadata_schema, tsk_size_t metadata_schema_length)\n{\n return replace_string(&self->metadata_schema, &self->metadata_schema_length,\n metadata_schema, metadata_schema_length);\n}\n\nint\ntsk_population_table_dump_text(const tsk_population_table_t *self, FILE *out)\n{\n int ret = TSK_ERR_IO;\n int err;\n tsk_size_t j;\n tsk_size_t metadata_len;\n\n err = write_metadata_schema_header(\n out, self->metadata_schema, self->metadata_schema_length);\n if (err < 0) {\n goto out;\n }\n err = fprintf(out, \"metadata\\n\");\n if (err < 0) {\n goto out;\n }\n for (j = 0; j < self->num_rows; j++) {\n metadata_len = self->metadata_offset[j + 1] - self->metadata_offset[j];\n err = fprintf(out, \"%.*s\\n\", (int) metadata_len,\n self->metadata + self->metadata_offset[j]);\n if (err < 0) {\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nbool\ntsk_population_table_equals(const tsk_population_table_t *self,\n const tsk_population_table_t *other, tsk_flags_t options)\n{\n /* Since we only have the metadata column in the table currently, equality\n * reduces to comparing the number of rows if we disable metadata comparison.\n */\n bool ret = self->num_rows == other->num_rows;\n if (!(options & TSK_CMP_IGNORE_METADATA)) {\n ret = ret && self->metadata_length == other->metadata_length\n && self->metadata_schema_length == other->metadata_schema_length\n && tsk_memcmp(self->metadata_offset, other->metadata_offset,\n (self->num_rows + 1) * sizeof(tsk_size_t))\n == 0\n && tsk_memcmp(self->metadata, other->metadata,\n self->metadata_length * sizeof(char))\n == 0\n && tsk_memcmp(self->metadata_schema, other->metadata_schema,\n self->metadata_schema_length * sizeof(char))\n == 0;\n }\n return ret;\n}\n\nint\ntsk_population_table_keep_rows(tsk_population_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t TSK_UNUSED(options), tsk_id_t *id_map)\n{\n int ret = 0;\n\n if (id_map != NULL) {\n keep_mask_to_id_map(self->num_rows, keep, id_map);\n }\n\n if (self->metadata_length > 0) {\n self->metadata_length = subset_ragged_char_column(\n self->metadata, self->metadata_offset, self->num_rows, keep);\n }\n self->num_rows = count_true(self->num_rows, keep);\n return ret;\n}\n\nstatic int\ntsk_population_table_dump(\n const tsk_population_table_t *self, kastore_t *store, tsk_flags_t options)\n{\n const write_table_col_t cols[] = {\n { \"populations/metadata_schema\", (void *) self->metadata_schema,\n self->metadata_schema_length, KAS_UINT8 },\n { .name = NULL },\n };\n const write_table_ragged_col_t ragged_cols[] = {\n { \"populations/metadata\", (void *) self->metadata, self->metadata_length,\n KAS_UINT8, self->metadata_offset, self->num_rows },\n { .name = NULL },\n };\n\n return write_table(store, cols, ragged_cols, options);\n}\n\nstatic int\ntsk_population_table_load(tsk_population_table_t *self, kastore_t *store)\n{\n int ret = 0;\n char *metadata = NULL;\n tsk_size_t *metadata_offset = NULL;\n char *metadata_schema = NULL;\n tsk_size_t num_rows, metadata_length, metadata_schema_length;\n\n read_table_ragged_col_t ragged_cols[] = {\n { \"populations/metadata\", (void **) &metadata, &metadata_length, KAS_UINT8,\n &metadata_offset, 0 },\n { .name = NULL },\n };\n read_table_property_t properties[] = {\n { \"populations/metadata_schema\", (void **) &metadata_schema,\n &metadata_schema_length, KAS_UINT8, TSK_COL_OPTIONAL },\n { .name = NULL },\n };\n\n ret = read_table(store, &num_rows, NULL, ragged_cols, properties, 0);\n if (ret != 0) {\n goto out;\n }\n if (metadata_schema != NULL) {\n ret = tsk_population_table_set_metadata_schema(\n self, metadata_schema, metadata_schema_length);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_population_table_takeset_columns(\n self, num_rows, metadata, metadata_offset);\n if (ret != 0) {\n goto out;\n }\n metadata = NULL;\n metadata_offset = NULL;\n\nout:\n free_read_table_mem(NULL, ragged_cols, properties);\n return ret;\n}\n\n/*************************\n * provenance table\n *************************/\n\nstatic void\ntsk_provenance_table_free_columns(tsk_provenance_table_t *self)\n{\n tsk_safe_free(self->timestamp);\n tsk_safe_free(self->timestamp_offset);\n tsk_safe_free(self->record);\n tsk_safe_free(self->record_offset);\n}\n\nint\ntsk_provenance_table_free(tsk_provenance_table_t *self)\n{\n tsk_provenance_table_free_columns(self);\n return 0;\n}\n\nstatic int\ntsk_provenance_table_expand_main_columns(\n tsk_provenance_table_t *self, tsk_size_t additional_rows)\n{\n int ret = 0;\n tsk_size_t new_max_rows;\n\n ret = calculate_max_rows(self->num_rows, self->max_rows, self->max_rows_increment,\n additional_rows, &new_max_rows);\n if (ret != 0) {\n goto out;\n }\n if ((self->num_rows + additional_rows) > self->max_rows) {\n ret = expand_column(\n (void **) &self->timestamp_offset, new_max_rows + 1, sizeof(tsk_size_t));\n if (ret != 0) {\n goto out;\n }\n ret = expand_column(\n (void **) &self->record_offset, new_max_rows + 1, sizeof(tsk_size_t));\n if (ret != 0) {\n goto out;\n }\n self->max_rows = new_max_rows;\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_provenance_table_expand_timestamp(\n tsk_provenance_table_t *self, tsk_size_t additional_length)\n{\n return expand_ragged_column(self->timestamp_length, additional_length,\n self->max_timestamp_length_increment, &self->max_timestamp_length,\n (void **) &self->timestamp, sizeof(*self->timestamp));\n}\n\nstatic int\ntsk_provenance_table_expand_record(\n tsk_provenance_table_t *self, tsk_size_t additional_length)\n{\n return expand_ragged_column(self->record_length, additional_length,\n self->max_record_length_increment, &self->max_record_length,\n (void **) &self->record, sizeof(*self->record));\n}\n\nint\ntsk_provenance_table_set_max_rows_increment(\n tsk_provenance_table_t *self, tsk_size_t max_rows_increment)\n{\n self->max_rows_increment = max_rows_increment;\n return 0;\n}\n\nint\ntsk_provenance_table_set_max_timestamp_length_increment(\n tsk_provenance_table_t *self, tsk_size_t max_timestamp_length_increment)\n{\n self->max_timestamp_length_increment = max_timestamp_length_increment;\n return 0;\n}\n\nint\ntsk_provenance_table_set_max_record_length_increment(\n tsk_provenance_table_t *self, tsk_size_t max_record_length_increment)\n{\n self->max_record_length_increment = max_record_length_increment;\n return 0;\n}\n\nint\ntsk_provenance_table_init(tsk_provenance_table_t *self, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n\n tsk_memset(self, 0, sizeof(tsk_provenance_table_t));\n /* Allocate space for one row initially, ensuring we always have valid pointers\n * even if the table is empty */\n self->max_rows_increment = 1;\n self->max_timestamp_length_increment = 1;\n self->max_record_length_increment = 1;\n ret = tsk_provenance_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_provenance_table_expand_timestamp(self, 1);\n if (ret != 0) {\n goto out;\n }\n self->timestamp_offset[0] = 0;\n ret = tsk_provenance_table_expand_record(self, 1);\n if (ret != 0) {\n goto out;\n }\n self->record_offset[0] = 0;\n self->max_rows_increment = 0;\n self->max_timestamp_length_increment = 0;\n self->max_record_length_increment = 0;\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_provenance_table_copy(const tsk_provenance_table_t *self,\n tsk_provenance_table_t *dest, tsk_flags_t options)\n{\n int ret = 0;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_provenance_table_init(dest, 0);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_provenance_table_set_columns(dest, self->num_rows, self->timestamp,\n self->timestamp_offset, self->record, self->record_offset);\nout:\n return ret;\n}\n\nint\ntsk_provenance_table_set_columns(tsk_provenance_table_t *self, tsk_size_t num_rows,\n const char *timestamp, const tsk_size_t *timestamp_offset, const char *record,\n const tsk_size_t *record_offset)\n{\n int ret;\n\n ret = tsk_provenance_table_clear(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_provenance_table_append_columns(\n self, num_rows, timestamp, timestamp_offset, record, record_offset);\nout:\n return ret;\n}\n\nint\ntsk_provenance_table_append_columns(tsk_provenance_table_t *self, tsk_size_t num_rows,\n const char *timestamp, const tsk_size_t *timestamp_offset, const char *record,\n const tsk_size_t *record_offset)\n{\n int ret;\n tsk_size_t j, timestamp_length, record_length;\n\n if (timestamp == NULL || timestamp_offset == NULL || record == NULL\n || record_offset == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n ret = tsk_provenance_table_expand_main_columns(self, num_rows);\n if (ret != 0) {\n goto out;\n }\n\n ret = check_offsets(num_rows, timestamp_offset, 0, false);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n self->timestamp_offset[self->num_rows + j]\n = self->timestamp_length + timestamp_offset[j];\n }\n timestamp_length = timestamp_offset[num_rows];\n ret = tsk_provenance_table_expand_timestamp(self, timestamp_length);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->timestamp + self->timestamp_length, timestamp,\n timestamp_length * sizeof(char));\n self->timestamp_length += timestamp_length;\n\n ret = check_offsets(num_rows, record_offset, 0, false);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n self->record_offset[self->num_rows + j] = self->record_length + record_offset[j];\n }\n record_length = record_offset[num_rows];\n ret = tsk_provenance_table_expand_record(self, record_length);\n if (ret != 0) {\n goto out;\n }\n tsk_memcpy(self->record + self->record_length, record, record_length * sizeof(char));\n self->record_length += record_length;\n\n self->num_rows += num_rows;\n self->timestamp_offset[self->num_rows] = self->timestamp_length;\n self->record_offset[self->num_rows] = self->record_length;\nout:\n return ret;\n}\n\nint\ntsk_provenance_table_takeset_columns(tsk_provenance_table_t *self, tsk_size_t num_rows,\n char *timestamp, tsk_size_t *timestamp_offset, char *record,\n tsk_size_t *record_offset)\n{\n int ret = 0;\n\n /* We need to check all the inputs before we start freeing or taking memory */\n if (timestamp == NULL || timestamp_offset == NULL || record == NULL\n || record_offset == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n ret = check_ragged_column(num_rows, timestamp, timestamp_offset);\n if (ret != 0) {\n goto out;\n }\n ret = check_ragged_column(num_rows, record, record_offset);\n if (ret != 0) {\n goto out;\n }\n\n tsk_provenance_table_free_columns(self);\n self->num_rows = num_rows;\n self->max_rows = num_rows;\n\n ret = takeset_ragged_column(num_rows, timestamp, timestamp_offset,\n (void *) &self->timestamp, &self->timestamp_offset, &self->timestamp_length);\n if (ret != 0) {\n goto out;\n }\n ret = takeset_ragged_column(num_rows, record, record_offset, (void *) &self->record,\n &self->record_offset, &self->record_length);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nstatic tsk_id_t\ntsk_provenance_table_add_row_internal(tsk_provenance_table_t *self,\n const char *timestamp, tsk_size_t timestamp_length, const char *record,\n tsk_size_t record_length)\n{\n tsk_id_t ret = 0;\n\n tsk_bug_assert(self->num_rows < self->max_rows);\n tsk_bug_assert(\n self->timestamp_length + timestamp_length <= self->max_timestamp_length);\n tsk_memmove(self->timestamp + self->timestamp_length, timestamp, timestamp_length);\n self->timestamp_offset[self->num_rows + 1]\n = self->timestamp_length + timestamp_length;\n self->timestamp_length += timestamp_length;\n tsk_bug_assert(self->record_length + record_length <= self->max_record_length);\n tsk_memmove(self->record + self->record_length, record, record_length);\n self->record_offset[self->num_rows + 1] = self->record_length + record_length;\n self->record_length += record_length;\n ret = (tsk_id_t) self->num_rows;\n self->num_rows++;\n return ret;\n}\n\ntsk_id_t\ntsk_provenance_table_add_row(tsk_provenance_table_t *self, const char *timestamp,\n tsk_size_t timestamp_length, const char *record, tsk_size_t record_length)\n{\n tsk_id_t ret = 0;\n\n ret = tsk_provenance_table_expand_main_columns(self, 1);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_provenance_table_expand_timestamp(self, timestamp_length);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_provenance_table_expand_record(self, record_length);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_provenance_table_add_row_internal(\n self, timestamp, timestamp_length, record, record_length);\nout:\n return ret;\n}\n\nstatic int\ntsk_provenance_table_update_row_rewrite(tsk_provenance_table_t *self, tsk_id_t index,\n const char *timestamp, tsk_size_t timestamp_length, const char *record,\n tsk_size_t record_length)\n{\n int ret = 0;\n tsk_id_t j, ret_id;\n tsk_provenance_table_t copy;\n tsk_size_t num_rows;\n tsk_id_t *rows = NULL;\n\n ret = tsk_provenance_table_copy(self, ©, 0);\n if (ret != 0) {\n goto out;\n }\n rows = tsk_malloc(self->num_rows * sizeof(*rows));\n if (rows == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n ret = tsk_provenance_table_truncate(self, (tsk_size_t) index);\n tsk_bug_assert(ret == 0);\n ret_id = tsk_provenance_table_add_row(\n self, timestamp, timestamp_length, record, record_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n num_rows = 0;\n for (j = index + 1; j < (tsk_id_t) copy.num_rows; j++) {\n rows[num_rows] = j;\n num_rows++;\n }\n ret = tsk_provenance_table_extend(self, ©, num_rows, rows, 0);\n if (ret != 0) {\n goto out;\n }\nout:\n tsk_provenance_table_free(©);\n tsk_safe_free(rows);\n return ret;\n}\n\nint\ntsk_provenance_table_update_row(tsk_provenance_table_t *self, tsk_id_t index,\n const char *timestamp, tsk_size_t timestamp_length, const char *record,\n tsk_size_t record_length)\n{\n int ret = 0;\n tsk_provenance_t current_row;\n\n ret = tsk_provenance_table_get_row(self, index, ¤t_row);\n if (ret != 0) {\n goto out;\n }\n if (current_row.timestamp_length == timestamp_length\n && current_row.record_length == record_length) {\n /* Note: important to use tsk_memmove here as we may be provided pointers\n * to the column memory as input via get_row */\n tsk_memmove(&self->timestamp[self->timestamp_offset[index]], timestamp,\n timestamp_length * sizeof(*timestamp));\n tsk_memmove(&self->record[self->record_offset[index]], record,\n record_length * sizeof(*record));\n } else {\n ret = tsk_provenance_table_update_row_rewrite(\n self, index, timestamp, timestamp_length, record, record_length);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nint\ntsk_provenance_table_clear(tsk_provenance_table_t *self)\n{\n return tsk_provenance_table_truncate(self, 0);\n}\n\nint\ntsk_provenance_table_truncate(tsk_provenance_table_t *self, tsk_size_t num_rows)\n{\n int ret = 0;\n\n if (num_rows > self->num_rows) {\n ret = tsk_trace_error(TSK_ERR_BAD_TABLE_POSITION);\n goto out;\n }\n self->num_rows = num_rows;\n self->timestamp_length = self->timestamp_offset[num_rows];\n self->record_length = self->record_offset[num_rows];\nout:\n return ret;\n}\n\nint\ntsk_provenance_table_extend(tsk_provenance_table_t *self,\n const tsk_provenance_table_t *other, tsk_size_t num_rows,\n const tsk_id_t *row_indexes, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_provenance_t provenance;\n\n if (self == other) {\n ret = tsk_trace_error(TSK_ERR_CANNOT_EXTEND_FROM_SELF);\n goto out;\n }\n\n /* We know how much to expand the non-ragged columns, so do it ahead of time */\n ret = tsk_provenance_table_expand_main_columns(self, num_rows);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_rows; j++) {\n ret = tsk_provenance_table_get_row(\n other, row_indexes == NULL ? (tsk_id_t) j : row_indexes[j], &provenance);\n if (ret != 0) {\n goto out;\n }\n ret_id = tsk_provenance_table_add_row(self, provenance.timestamp,\n provenance.timestamp_length, provenance.record, provenance.record_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nvoid\ntsk_provenance_table_print_state(const tsk_provenance_table_t *self, FILE *out)\n{\n tsk_size_t j, k;\n\n fprintf(out, \"\\n\" TABLE_SEP);\n fprintf(out, \"provenance_table: %p:\\n\", (const void *) self);\n fprintf(out, \"num_rows = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->num_rows, (long long) self->max_rows,\n (long long) self->max_rows_increment);\n fprintf(out, \"timestamp_length = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->timestamp_length, (long long) self->max_timestamp_length,\n (long long) self->max_timestamp_length_increment);\n fprintf(out, \"record_length = %lld\\tmax= %lld\\tincrement = %lld)\\n\",\n (long long) self->record_length, (long long) self->max_record_length,\n (long long) self->max_record_length_increment);\n fprintf(out, TABLE_SEP);\n fprintf(out, \"index\\ttimestamp_offset\\ttimestamp\\trecord_offset\\tprovenance\\n\");\n for (j = 0; j < self->num_rows; j++) {\n fprintf(\n out, \"%lld\\t%lld\\t\", (long long) j, (long long) self->timestamp_offset[j]);\n for (k = self->timestamp_offset[j]; k < self->timestamp_offset[j + 1]; k++) {\n fprintf(out, \"%c\", self->timestamp[k]);\n }\n fprintf(out, \"\\t%lld\\t\", (long long) self->record_offset[j]);\n for (k = self->record_offset[j]; k < self->record_offset[j + 1]; k++) {\n fprintf(out, \"%c\", self->record[k]);\n }\n fprintf(out, \"\\n\");\n }\n tsk_bug_assert(self->timestamp_offset[0] == 0);\n tsk_bug_assert(self->timestamp_offset[self->num_rows] == self->timestamp_length);\n tsk_bug_assert(self->record_offset[0] == 0);\n tsk_bug_assert(self->record_offset[self->num_rows] == self->record_length);\n}\n\nstatic inline void\ntsk_provenance_table_get_row_unsafe(\n const tsk_provenance_table_t *self, tsk_id_t index, tsk_provenance_t *row)\n{\n row->id = (tsk_id_t) index;\n row->timestamp_length\n = self->timestamp_offset[index + 1] - self->timestamp_offset[index];\n row->timestamp = self->timestamp + self->timestamp_offset[index];\n row->record_length = self->record_offset[index + 1] - self->record_offset[index];\n row->record = self->record + self->record_offset[index];\n}\n\nint\ntsk_provenance_table_get_row(\n const tsk_provenance_table_t *self, tsk_id_t index, tsk_provenance_t *row)\n{\n int ret = 0;\n\n if (index < 0 || index >= (tsk_id_t) self->num_rows) {\n ret = tsk_trace_error(TSK_ERR_PROVENANCE_OUT_OF_BOUNDS);\n goto out;\n }\n tsk_provenance_table_get_row_unsafe(self, index, row);\nout:\n return ret;\n}\n\nint\ntsk_provenance_table_dump_text(const tsk_provenance_table_t *self, FILE *out)\n{\n int ret = TSK_ERR_IO;\n int err;\n tsk_size_t j, timestamp_len, record_len;\n\n err = fprintf(out, \"record\\ttimestamp\\n\");\n if (err < 0) {\n goto out;\n }\n for (j = 0; j < self->num_rows; j++) {\n record_len = self->record_offset[j + 1] - self->record_offset[j];\n timestamp_len = self->timestamp_offset[j + 1] - self->timestamp_offset[j];\n err = fprintf(out, \"%.*s\\t%.*s\\n\", (int) record_len,\n self->record + self->record_offset[j], (int) timestamp_len,\n self->timestamp + self->timestamp_offset[j]);\n if (err < 0) {\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nbool\ntsk_provenance_table_equals(const tsk_provenance_table_t *self,\n const tsk_provenance_table_t *other, tsk_flags_t options)\n{\n bool ret\n = self->num_rows == other->num_rows\n && self->record_length == other->record_length\n && tsk_memcmp(self->record_offset, other->record_offset,\n (self->num_rows + 1) * sizeof(tsk_size_t))\n == 0\n && tsk_memcmp(self->record, other->record, self->record_length * sizeof(char))\n == 0;\n if (!(options & TSK_CMP_IGNORE_TIMESTAMPS)) {\n ret = ret && self->timestamp_length == other->timestamp_length\n && tsk_memcmp(self->timestamp_offset, other->timestamp_offset,\n (self->num_rows + 1) * sizeof(tsk_size_t))\n == 0\n && tsk_memcmp(self->timestamp, other->timestamp,\n self->timestamp_length * sizeof(char))\n == 0;\n }\n return ret;\n}\n\nint\ntsk_provenance_table_keep_rows(tsk_provenance_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t TSK_UNUSED(options), tsk_id_t *id_map)\n{\n int ret = 0;\n\n if (id_map != NULL) {\n keep_mask_to_id_map(self->num_rows, keep, id_map);\n }\n self->timestamp_length = subset_ragged_char_column(\n self->timestamp, self->timestamp_offset, self->num_rows, keep);\n self->record_length = subset_ragged_char_column(\n self->record, self->record_offset, self->num_rows, keep);\n self->num_rows = count_true(self->num_rows, keep);\n\n return ret;\n}\n\nstatic int\ntsk_provenance_table_dump(\n const tsk_provenance_table_t *self, kastore_t *store, tsk_flags_t options)\n{\n write_table_ragged_col_t ragged_cols[] = {\n { \"provenances/timestamp\", (void *) self->timestamp, self->timestamp_length,\n KAS_UINT8, self->timestamp_offset, self->num_rows },\n { \"provenances/record\", (void *) self->record, self->record_length, KAS_UINT8,\n self->record_offset, self->num_rows },\n { .name = NULL },\n };\n\n return write_table_ragged_cols(store, ragged_cols, options);\n}\n\nstatic int\ntsk_provenance_table_load(tsk_provenance_table_t *self, kastore_t *store)\n{\n int ret;\n char *timestamp = NULL;\n tsk_size_t *timestamp_offset = NULL;\n char *record = NULL;\n tsk_size_t *record_offset = NULL;\n tsk_size_t num_rows, timestamp_length, record_length;\n\n read_table_ragged_col_t ragged_cols[] = {\n { \"provenances/timestamp\", (void **) ×tamp, ×tamp_length, KAS_UINT8,\n ×tamp_offset, 0 },\n { \"provenances/record\", (void **) &record, &record_length, KAS_UINT8,\n &record_offset, 0 },\n { .name = NULL },\n };\n\n ret = read_table(store, &num_rows, NULL, ragged_cols, NULL, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_provenance_table_takeset_columns(\n self, num_rows, timestamp, timestamp_offset, record, record_offset);\n if (ret != 0) {\n goto out;\n }\n timestamp = NULL;\n timestamp_offset = NULL;\n record = NULL;\n record_offset = NULL;\n\nout:\n free_read_table_mem(NULL, ragged_cols, NULL);\n return ret;\n}\n\n/*************************\n * sort_tables\n *************************/\n\ntypedef struct {\n double left;\n double right;\n tsk_id_t parent;\n tsk_id_t child;\n double time;\n /* It would be a little bit more convenient to store a pointer to the\n * metadata here in the struct rather than an offset back into the\n * original array. However, this would increase the size of the struct\n * from 40 bytes to 48 and we will allocate very large numbers of these.\n */\n tsk_size_t metadata_offset;\n tsk_size_t metadata_length;\n} edge_sort_t;\n\ntypedef struct {\n tsk_mutation_t mut;\n int num_descendants;\n double node_time;\n} mutation_sort_t;\n\ntypedef struct {\n tsk_individual_t ind;\n tsk_id_t first_node;\n tsk_size_t num_descendants;\n} individual_canonical_sort_t;\n\ntypedef struct {\n double left;\n double right;\n tsk_id_t node;\n tsk_id_t source;\n tsk_id_t dest;\n double time;\n tsk_size_t metadata_offset;\n tsk_size_t metadata_length;\n} migration_sort_t;\n\nstatic int\ncmp_site(const void *a, const void *b)\n{\n const tsk_site_t *ia = (const tsk_site_t *) a;\n const tsk_site_t *ib = (const tsk_site_t *) b;\n /* Compare sites by position */\n int ret = (ia->position > ib->position) - (ia->position < ib->position);\n if (ret == 0) {\n /* Within a particular position sort by ID. This ensures that relative\n * ordering of multiple sites at the same position is maintained; the\n * redundant sites will get compacted down by clean_tables(), but in the\n * meantime if the order of the redundant sites changes it will cause the\n * sort order of mutations to be corrupted, as the mutations will follow\n * their sites. */\n ret = (ia->id > ib->id) - (ia->id < ib->id);\n }\n return ret;\n}\n\nstatic int\ncmp_mutation(const void *a, const void *b)\n{\n const mutation_sort_t *ia = (const mutation_sort_t *) a;\n const mutation_sort_t *ib = (const mutation_sort_t *) b;\n /* Compare mutations by site */\n int ret = (ia->mut.site > ib->mut.site) - (ia->mut.site < ib->mut.site);\n\n /* Within a particular site sort by time if known */\n if (ret == 0 && !tsk_is_unknown_time(ia->mut.time)\n && !tsk_is_unknown_time(ib->mut.time)) {\n ret = (ia->mut.time < ib->mut.time) - (ia->mut.time > ib->mut.time);\n }\n /* Or node times when mutation times are unknown or equal */\n if (ret == 0) {\n ret = (ia->node_time < ib->node_time) - (ia->node_time > ib->node_time);\n }\n /* If node times are equal, sort by number of descendants */\n if (ret == 0) {\n ret = (ia->num_descendants < ib->num_descendants)\n - (ia->num_descendants > ib->num_descendants);\n }\n /* If number of descendants are equal, sort by node */\n if (ret == 0) {\n ret = (ia->mut.node > ib->mut.node) - (ia->mut.node < ib->mut.node);\n }\n /* Final tiebreaker: ID */\n if (ret == 0) {\n ret = (ia->mut.id > ib->mut.id) - (ia->mut.id < ib->mut.id);\n }\n return ret;\n}\n\nstatic int\ncmp_individual_canonical(const void *a, const void *b)\n{\n const individual_canonical_sort_t *ia = (const individual_canonical_sort_t *) a;\n const individual_canonical_sort_t *ib = (const individual_canonical_sort_t *) b;\n int ret = (ia->num_descendants < ib->num_descendants)\n - (ia->num_descendants > ib->num_descendants);\n if (ret == 0) {\n ret = (ia->first_node > ib->first_node) - (ia->first_node < ib->first_node);\n }\n if (ret == 0) {\n ret = (ia->ind.id > ib->ind.id) - (ia->ind.id < ib->ind.id);\n }\n return ret;\n}\n\nstatic int\ncmp_edge(const void *a, const void *b)\n{\n const edge_sort_t *ca = (const edge_sort_t *) a;\n const edge_sort_t *cb = (const edge_sort_t *) b;\n\n int ret = (ca->time > cb->time) - (ca->time < cb->time);\n /* If time values are equal, sort by the parent node */\n if (ret == 0) {\n ret = (ca->parent > cb->parent) - (ca->parent < cb->parent);\n /* If the parent nodes are equal, sort by the child ID. */\n if (ret == 0) {\n ret = (ca->child > cb->child) - (ca->child < cb->child);\n /* If the child nodes are equal, sort by the left coordinate. */\n if (ret == 0) {\n ret = (ca->left > cb->left) - (ca->left < cb->left);\n }\n }\n }\n return ret;\n}\n\nstatic int\ncmp_migration(const void *a, const void *b)\n{\n const migration_sort_t *ca = (const migration_sort_t *) a;\n const migration_sort_t *cb = (const migration_sort_t *) b;\n\n int ret = (ca->time > cb->time) - (ca->time < cb->time);\n /* If time values are equal, sort by the source population */\n if (ret == 0) {\n ret = (ca->source > cb->source) - (ca->source < cb->source);\n /* If the source populations are equal, sort by the dest */\n if (ret == 0) {\n ret = (ca->dest > cb->dest) - (ca->dest < cb->dest);\n /* If the dest populations are equal, sort by the left coordinate. */\n if (ret == 0) {\n ret = (ca->left > cb->left) - (ca->left < cb->left);\n /* If everything else is equal, compare by node */\n if (ret == 0) {\n ret = (ca->node > cb->node) - (ca->node < cb->node);\n }\n }\n }\n }\n return ret;\n}\n\nstatic int\ntsk_table_sorter_sort_edges(tsk_table_sorter_t *self, tsk_size_t start)\n{\n int ret = 0;\n const tsk_edge_table_t *edges = &self->tables->edges;\n const double *restrict node_time = self->tables->nodes.time;\n edge_sort_t *e;\n tsk_size_t j, k, metadata_offset;\n tsk_size_t n = edges->num_rows - start;\n edge_sort_t *sorted_edges = tsk_malloc(n * sizeof(*sorted_edges));\n char *old_metadata = tsk_malloc(edges->metadata_length);\n bool has_metadata = tsk_edge_table_has_metadata(edges);\n\n if (sorted_edges == NULL || old_metadata == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memcpy(old_metadata, edges->metadata, edges->metadata_length);\n for (j = 0; j < n; j++) {\n e = sorted_edges + j;\n k = start + j;\n e->left = edges->left[k];\n e->right = edges->right[k];\n e->parent = edges->parent[k];\n e->child = edges->child[k];\n e->time = node_time[e->parent];\n if (has_metadata) {\n e->metadata_offset = edges->metadata_offset[k];\n e->metadata_length\n = edges->metadata_offset[k + 1] - edges->metadata_offset[k];\n }\n }\n qsort(sorted_edges, (size_t) n, sizeof(edge_sort_t), cmp_edge);\n /* Copy the edges back into the table. */\n metadata_offset = 0;\n for (j = 0; j < n; j++) {\n e = sorted_edges + j;\n k = start + j;\n edges->left[k] = e->left;\n edges->right[k] = e->right;\n edges->parent[k] = e->parent;\n edges->child[k] = e->child;\n if (has_metadata) {\n tsk_memcpy(edges->metadata + metadata_offset,\n old_metadata + e->metadata_offset, e->metadata_length);\n edges->metadata_offset[k] = metadata_offset;\n metadata_offset += e->metadata_length;\n }\n }\nout:\n tsk_safe_free(sorted_edges);\n tsk_safe_free(old_metadata);\n return ret;\n}\n\nstatic int\ntsk_table_sorter_sort_migrations(tsk_table_sorter_t *self, tsk_size_t start)\n{\n int ret = 0;\n const tsk_migration_table_t *migrations = &self->tables->migrations;\n migration_sort_t *m;\n tsk_size_t j, k, metadata_offset;\n tsk_size_t n = migrations->num_rows - start;\n migration_sort_t *sorted_migrations = tsk_malloc(n * sizeof(*sorted_migrations));\n char *old_metadata = tsk_malloc(migrations->metadata_length);\n\n if (sorted_migrations == NULL || old_metadata == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memcpy(old_metadata, migrations->metadata, migrations->metadata_length);\n for (j = 0; j < n; j++) {\n m = sorted_migrations + j;\n k = start + j;\n m->left = migrations->left[k];\n m->right = migrations->right[k];\n m->node = migrations->node[k];\n m->source = migrations->source[k];\n m->dest = migrations->dest[k];\n m->time = migrations->time[k];\n m->metadata_offset = migrations->metadata_offset[k];\n m->metadata_length\n = migrations->metadata_offset[k + 1] - migrations->metadata_offset[k];\n }\n qsort(sorted_migrations, (size_t) n, sizeof(migration_sort_t), cmp_migration);\n /* Copy the migrations back into the table. */\n metadata_offset = 0;\n for (j = 0; j < n; j++) {\n m = sorted_migrations + j;\n k = start + j;\n migrations->left[k] = m->left;\n migrations->right[k] = m->right;\n migrations->node[k] = m->node;\n migrations->source[k] = m->source;\n migrations->dest[k] = m->dest;\n migrations->time[k] = m->time;\n tsk_memcpy(migrations->metadata + metadata_offset,\n old_metadata + m->metadata_offset, m->metadata_length);\n migrations->metadata_offset[k] = metadata_offset;\n metadata_offset += m->metadata_length;\n }\nout:\n tsk_safe_free(sorted_migrations);\n tsk_safe_free(old_metadata);\n return ret;\n}\n\nstatic int\ntsk_table_sorter_sort_sites(tsk_table_sorter_t *self)\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_site_table_t *sites = &self->tables->sites;\n tsk_site_table_t copy;\n tsk_size_t j;\n tsk_size_t num_sites = sites->num_rows;\n tsk_site_t *sorted_sites = tsk_malloc(num_sites * sizeof(*sorted_sites));\n\n ret = tsk_site_table_copy(sites, ©, 0);\n if (ret != 0) {\n goto out;\n }\n if (sorted_sites == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n for (j = 0; j < num_sites; j++) {\n tsk_site_table_get_row_unsafe(©, (tsk_id_t) j, sorted_sites + j);\n }\n\n /* Sort the sites by position */\n qsort(sorted_sites, (size_t) num_sites, sizeof(*sorted_sites), cmp_site);\n\n /* Build the mapping from old site IDs to new site IDs and copy back into the\n * table\n */\n tsk_site_table_clear(sites);\n for (j = 0; j < num_sites; j++) {\n self->site_id_map[sorted_sites[j].id] = (tsk_id_t) j;\n ret_id = tsk_site_table_add_row(sites, sorted_sites[j].position,\n sorted_sites[j].ancestral_state, sorted_sites[j].ancestral_state_length,\n sorted_sites[j].metadata, sorted_sites[j].metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n ret = 0;\nout:\n tsk_safe_free(sorted_sites);\n tsk_site_table_free(©);\n return ret;\n}\n\nstatic int\ntsk_table_sorter_sort_mutations(tsk_table_sorter_t *self)\n{\n int ret = 0;\n tsk_size_t j;\n tsk_id_t ret_id, parent, mapped_parent, p;\n tsk_mutation_table_t *mutations = &self->tables->mutations;\n tsk_node_table_t *nodes = &self->tables->nodes;\n tsk_size_t num_mutations = mutations->num_rows;\n tsk_mutation_table_t copy;\n mutation_sort_t *sorted_mutations\n = tsk_malloc(num_mutations * sizeof(*sorted_mutations));\n tsk_id_t *mutation_id_map = tsk_malloc(num_mutations * sizeof(*mutation_id_map));\n\n ret = tsk_mutation_table_copy(mutations, ©, 0);\n if (ret != 0) {\n goto out;\n }\n if (mutation_id_map == NULL || sorted_mutations == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n /* compute numbers of descendants for each mutation */\n for (j = 0; j < num_mutations; j++) {\n sorted_mutations[j].num_descendants = 0;\n }\n for (j = 0; j < num_mutations; j++) {\n p = mutations->parent[j];\n while (p != TSK_NULL) {\n sorted_mutations[p].num_descendants += 1;\n if (sorted_mutations[p].num_descendants > (int) num_mutations) {\n ret = tsk_trace_error(TSK_ERR_MUTATION_PARENT_INCONSISTENT);\n goto out;\n }\n p = mutations->parent[p];\n }\n }\n\n for (j = 0; j < num_mutations; j++) {\n tsk_mutation_table_get_row_unsafe(©, (tsk_id_t) j, &sorted_mutations[j].mut);\n sorted_mutations[j].mut.site = self->site_id_map[sorted_mutations[j].mut.site];\n sorted_mutations[j].node_time = nodes->time[sorted_mutations[j].mut.node];\n }\n ret = tsk_mutation_table_clear(mutations);\n if (ret != 0) {\n goto out;\n }\n\n qsort(sorted_mutations, (size_t) num_mutations, sizeof(*sorted_mutations),\n cmp_mutation);\n\n /* Make a first pass through the sorted mutations to build the ID map. */\n for (j = 0; j < num_mutations; j++) {\n mutation_id_map[sorted_mutations[j].mut.id] = (tsk_id_t) j;\n }\n\n for (j = 0; j < num_mutations; j++) {\n mapped_parent = TSK_NULL;\n parent = sorted_mutations[j].mut.parent;\n if (parent != TSK_NULL) {\n mapped_parent = mutation_id_map[parent];\n }\n ret_id = tsk_mutation_table_add_row(mutations, sorted_mutations[j].mut.site,\n sorted_mutations[j].mut.node, mapped_parent, sorted_mutations[j].mut.time,\n sorted_mutations[j].mut.derived_state,\n sorted_mutations[j].mut.derived_state_length,\n sorted_mutations[j].mut.metadata, sorted_mutations[j].mut.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n ret = 0;\n\nout:\n tsk_safe_free(mutation_id_map);\n tsk_safe_free(sorted_mutations);\n tsk_mutation_table_free(©);\n return ret;\n}\n\nstatic int\ntsk_individual_table_topological_sort(\n tsk_individual_table_t *self, tsk_id_t *traversal_order, tsk_size_t *num_descendants)\n{\n int ret = 0;\n tsk_id_t i, j, p;\n tsk_individual_t individual;\n tsk_size_t num_individuals = self->num_rows;\n tsk_size_t current_todo = 0;\n tsk_size_t todo_insertion_point = 0;\n tsk_size_t *incoming_edge_count\n = tsk_malloc(num_individuals * sizeof(*incoming_edge_count));\n bool count_descendants = (num_descendants != NULL);\n\n if (incoming_edge_count == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n for (i = 0; i < (tsk_id_t) num_individuals; i++) {\n incoming_edge_count[i] = 0;\n traversal_order[i] = TSK_NULL;\n if (count_descendants) {\n num_descendants[i] = 0;\n }\n }\n\n /* First find the set of individuals that have no children by creating\n * an array of incoming edge counts */\n for (i = 0; i < (tsk_id_t) self->parents_length; i++) {\n if (self->parents[i] != TSK_NULL) {\n incoming_edge_count[self->parents[i]]++;\n }\n }\n /* Use these as the starting points for checking all individuals,\n * doing this in reverse makes the sort stable */\n for (i = (tsk_id_t) num_individuals - 1; i >= 0; i--) {\n if (incoming_edge_count[i] == 0) {\n traversal_order[todo_insertion_point] = i;\n todo_insertion_point++;\n }\n }\n\n /* Now process individuals from the set that have no children, updating their\n * parents' information as we go, and adding their parents to the list if\n * this was their last child */\n while (current_todo < todo_insertion_point) {\n j = traversal_order[current_todo];\n tsk_individual_table_get_row_unsafe(self, j, &individual);\n for (i = 0; i < (tsk_id_t) individual.parents_length; i++) {\n p = individual.parents[i];\n if (p != TSK_NULL) {\n incoming_edge_count[p]--;\n if (count_descendants) {\n num_descendants[p] += 1 + num_descendants[j];\n }\n if (incoming_edge_count[p] == 0) {\n traversal_order[todo_insertion_point] = p;\n todo_insertion_point++;\n }\n }\n }\n current_todo++;\n }\n\n /* Any edges left are parts of cycles */\n for (i = 0; i < (tsk_id_t) num_individuals; i++) {\n if (incoming_edge_count[i] > 0) {\n ret = tsk_trace_error(TSK_ERR_INDIVIDUAL_PARENT_CYCLE);\n goto out;\n }\n }\n\nout:\n tsk_safe_free(incoming_edge_count);\n return ret;\n}\n\nint\ntsk_table_collection_individual_topological_sort(\n tsk_table_collection_t *self, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_id_t i, ret_id;\n tsk_individual_table_t copy;\n tsk_individual_t individual;\n tsk_individual_table_t *individuals = &self->individuals;\n tsk_node_table_t *nodes = &self->nodes;\n tsk_size_t num_individuals = individuals->num_rows;\n tsk_id_t *traversal_order = tsk_malloc(num_individuals * sizeof(*traversal_order));\n tsk_id_t *new_id_map = tsk_malloc(num_individuals * sizeof(*new_id_map));\n\n if (new_id_map == NULL || traversal_order == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(new_id_map, 0xff, num_individuals * sizeof(*new_id_map));\n\n ret = tsk_individual_table_copy(individuals, ©, 0);\n if (ret != 0) {\n goto out;\n }\n\n ret_id = tsk_table_collection_check_integrity(self, 0);\n if (ret_id != 0) {\n ret = (int) ret_id;\n goto out;\n }\n\n ret = tsk_individual_table_clear(individuals);\n if (ret != 0) {\n goto out;\n }\n\n ret = tsk_individual_table_topological_sort(©, traversal_order, NULL);\n if (ret != 0) {\n goto out;\n }\n\n /* The sorted individuals are in reverse order */\n for (i = (tsk_id_t) num_individuals - 1; i >= 0; i--) {\n tsk_individual_table_get_row_unsafe(©, traversal_order[i], &individual);\n ret_id = tsk_individual_table_add_row(individuals, individual.flags,\n individual.location, individual.location_length, individual.parents,\n individual.parents_length, individual.metadata, individual.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n new_id_map[traversal_order[i]] = ret_id;\n }\n\n /* Rewrite the parent ids */\n for (i = 0; i < (tsk_id_t) individuals->parents_length; i++) {\n if (individuals->parents[i] != TSK_NULL) {\n individuals->parents[i] = new_id_map[individuals->parents[i]];\n }\n }\n /* Rewrite the node individual ids */\n for (i = 0; i < (tsk_id_t) nodes->num_rows; i++) {\n if (nodes->individual[i] != TSK_NULL) {\n nodes->individual[i] = new_id_map[nodes->individual[i]];\n }\n }\n\n ret = 0;\nout:\n tsk_safe_free(traversal_order);\n tsk_safe_free(new_id_map);\n tsk_individual_table_free(©);\n return ret;\n}\n\nstatic int\ntsk_table_sorter_sort_individuals_canonical(tsk_table_sorter_t *self)\n{\n int ret = 0;\n tsk_id_t ret_id, i, j, parent, mapped_parent;\n tsk_individual_table_t *individuals = &self->tables->individuals;\n tsk_node_table_t *nodes = &self->tables->nodes;\n tsk_individual_table_t copy;\n tsk_size_t num_individuals = individuals->num_rows;\n individual_canonical_sort_t *sorted_individuals\n = tsk_malloc(num_individuals * sizeof(*sorted_individuals));\n tsk_id_t *individual_id_map\n = tsk_malloc(num_individuals * sizeof(*individual_id_map));\n tsk_size_t *num_descendants = tsk_malloc(num_individuals * sizeof(*num_descendants));\n tsk_id_t *traversal_order = tsk_malloc(num_individuals * sizeof(*traversal_order));\n\n if (individual_id_map == NULL || sorted_individuals == NULL\n || traversal_order == NULL || num_descendants == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n ret = tsk_individual_table_copy(individuals, ©, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_individual_table_clear(individuals);\n if (ret != 0) {\n goto out;\n }\n\n ret = tsk_individual_table_topological_sort(©, traversal_order, num_descendants);\n if (ret != 0) {\n goto out;\n }\n\n for (i = 0; i < (tsk_id_t) num_individuals; i++) {\n sorted_individuals[i].num_descendants = num_descendants[i];\n sorted_individuals[i].first_node = (tsk_id_t) nodes->num_rows;\n }\n\n /* find first referring node */\n for (j = 0; j < (tsk_id_t) nodes->num_rows; j++) {\n if (nodes->individual[j] != TSK_NULL) {\n sorted_individuals[nodes->individual[j]].first_node\n = TSK_MIN(j, sorted_individuals[nodes->individual[j]].first_node);\n }\n }\n\n for (j = 0; j < (tsk_id_t) num_individuals; j++) {\n tsk_individual_table_get_row_unsafe(\n ©, (tsk_id_t) j, &sorted_individuals[j].ind);\n }\n\n qsort(sorted_individuals, (size_t) num_individuals, sizeof(*sorted_individuals),\n cmp_individual_canonical);\n\n /* Make a first pass through the sorted individuals to build the ID map. */\n for (j = 0; j < (tsk_id_t) num_individuals; j++) {\n individual_id_map[sorted_individuals[j].ind.id] = (tsk_id_t) j;\n }\n\n for (i = 0; i < (tsk_id_t) num_individuals; i++) {\n for (j = 0; j < (tsk_id_t) sorted_individuals[i].ind.parents_length; j++) {\n parent = sorted_individuals[i].ind.parents[j];\n if (parent != TSK_NULL) {\n mapped_parent = individual_id_map[parent];\n sorted_individuals[i].ind.parents[j] = mapped_parent;\n }\n }\n ret_id = tsk_individual_table_add_row(individuals,\n sorted_individuals[i].ind.flags, sorted_individuals[i].ind.location,\n sorted_individuals[i].ind.location_length, sorted_individuals[i].ind.parents,\n sorted_individuals[i].ind.parents_length, sorted_individuals[i].ind.metadata,\n sorted_individuals[i].ind.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n ret = 0;\n\n /* remap individuals in the node table */\n for (i = 0; i < (tsk_id_t) nodes->num_rows; i++) {\n j = nodes->individual[i];\n if (j != TSK_NULL) {\n nodes->individual[i] = individual_id_map[j];\n }\n }\n\nout:\n tsk_safe_free(sorted_individuals);\n tsk_safe_free(individual_id_map);\n tsk_safe_free(traversal_order);\n tsk_safe_free(num_descendants);\n tsk_individual_table_free(©);\n return ret;\n}\n\nint\ntsk_table_sorter_run(tsk_table_sorter_t *self, const tsk_bookmark_t *start)\n{\n int ret = 0;\n tsk_size_t edge_start = 0;\n tsk_size_t migration_start = 0;\n bool skip_sites = false;\n bool skip_individuals = false;\n\n if (start != NULL) {\n if (start->edges > self->tables->edges.num_rows) {\n ret = tsk_trace_error(TSK_ERR_EDGE_OUT_OF_BOUNDS);\n goto out;\n }\n edge_start = start->edges;\n if (start->migrations > self->tables->migrations.num_rows) {\n ret = tsk_trace_error(TSK_ERR_MIGRATION_OUT_OF_BOUNDS);\n goto out;\n }\n migration_start = start->migrations;\n\n /* We only allow sites and mutations to be specified as a way to\n * skip sorting them entirely. Both sites and mutations must be\n * equal to the number of rows */\n if (start->sites == self->tables->sites.num_rows\n && start->mutations == self->tables->mutations.num_rows) {\n skip_sites = true;\n } else if (start->sites != 0 || start->mutations != 0) {\n ret = tsk_trace_error(TSK_ERR_SORT_OFFSET_NOT_SUPPORTED);\n goto out;\n }\n }\n /* The indexes will be invalidated, so drop them */\n ret = tsk_table_collection_drop_index(self->tables, 0);\n if (ret != 0) {\n goto out;\n }\n\n if (self->sort_edges != NULL) {\n ret = self->sort_edges(self, edge_start);\n if (ret != 0) {\n goto out;\n }\n }\n /* Avoid calling sort_migrations in the common case when it's a no-op */\n if (self->tables->migrations.num_rows > 0) {\n ret = tsk_table_sorter_sort_migrations(self, migration_start);\n if (ret != 0) {\n goto out;\n }\n }\n if (!skip_sites) {\n ret = tsk_table_sorter_sort_sites(self);\n if (ret != 0) {\n goto out;\n }\n ret = self->sort_mutations(self);\n if (ret != 0) {\n goto out;\n }\n }\n if (!skip_individuals && self->sort_individuals != NULL) {\n ret = self->sort_individuals(self);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nint\ntsk_table_sorter_init(\n tsk_table_sorter_t *self, tsk_table_collection_t *tables, tsk_flags_t options)\n{\n int ret = 0;\n tsk_id_t ret_id;\n\n tsk_memset(self, 0, sizeof(tsk_table_sorter_t));\n if (!(options & TSK_NO_CHECK_INTEGRITY)) {\n ret_id = tsk_table_collection_check_integrity(tables, 0);\n if (ret_id != 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n self->tables = tables;\n\n self->site_id_map = tsk_malloc(self->tables->sites.num_rows * sizeof(tsk_id_t));\n if (self->site_id_map == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n /* Set the sort_edges and sort_mutations methods to the default. */\n self->sort_edges = tsk_table_sorter_sort_edges;\n self->sort_mutations = tsk_table_sorter_sort_mutations;\n /* Default sort doesn't touch individuals */\n self->sort_individuals = NULL;\nout:\n return ret;\n}\n\nint\ntsk_table_sorter_free(tsk_table_sorter_t *self)\n{\n tsk_safe_free(self->site_id_map);\n return 0;\n}\n\n/*************************\n * segment overlapper\n *************************/\n\ntypedef struct _interval_list_t {\n double left;\n double right;\n struct _interval_list_t *next;\n} interval_list_t;\n\ntypedef struct _mutation_id_list_t {\n tsk_id_t mutation;\n struct _mutation_id_list_t *next;\n} mutation_id_list_t;\n\ntypedef struct _tsk_segment_t {\n double left;\n double right;\n struct _tsk_segment_t *next;\n tsk_id_t node;\n} tsk_segment_t;\n\n/* segment overlap finding algorithm */\ntypedef struct {\n /* The input segments. This buffer is sorted by the algorithm and we also\n * assume that there is space for an extra element at the end */\n tsk_segment_t *segments;\n tsk_size_t num_segments;\n tsk_size_t index;\n tsk_size_t num_overlapping;\n double left;\n double right;\n /* Output buffer */\n tsk_size_t max_overlapping;\n tsk_segment_t **overlapping;\n} segment_overlapper_t;\n\ntypedef struct {\n tsk_size_t num_samples;\n tsk_flags_t options;\n tsk_table_collection_t *tables;\n /* Keep a copy of the input tables */\n tsk_table_collection_t input_tables;\n /* State for topology */\n tsk_segment_t **ancestor_map_head;\n tsk_segment_t **ancestor_map_tail;\n /* Mapping of input node IDs to output node IDs. */\n tsk_id_t *node_id_map;\n bool *is_sample;\n /* Segments for a particular parent that are processed together */\n tsk_segment_t *segment_queue;\n tsk_size_t segment_queue_size;\n tsk_size_t max_segment_queue_size;\n segment_overlapper_t segment_overlapper;\n tsk_blkalloc_t segment_heap;\n /* Buffer for output edges. For each child we keep a linked list of\n * intervals, and also store the actual children that have been buffered. */\n tsk_blkalloc_t interval_list_heap;\n interval_list_t **child_edge_map_head;\n interval_list_t **child_edge_map_tail;\n tsk_id_t *buffered_children;\n tsk_size_t num_buffered_children;\n /* For each mutation, map its output node. */\n tsk_id_t *mutation_node_map;\n /* Map of input nodes to the list of input mutation IDs */\n mutation_id_list_t **node_mutation_list_map_head;\n mutation_id_list_t **node_mutation_list_map_tail;\n mutation_id_list_t *node_mutation_list_mem;\n /* When reducing topology, we need a map positions to their corresponding\n * sites.*/\n double *position_lookup;\n int64_t edge_sort_offset;\n} simplifier_t;\n\nstatic int\ncmp_segment(const void *a, const void *b)\n{\n const tsk_segment_t *ia = (const tsk_segment_t *) a;\n const tsk_segment_t *ib = (const tsk_segment_t *) b;\n int ret = (ia->left > ib->left) - (ia->left < ib->left);\n /* Break ties using the node */\n if (ret == 0) {\n ret = (ia->node > ib->node) - (ia->node < ib->node);\n }\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\nsegment_overlapper_alloc(segment_overlapper_t *self)\n{\n int ret = 0;\n\n tsk_memset(self, 0, sizeof(*self));\n self->max_overlapping = 8; /* Making sure we call tsk_realloc in tests */\n self->overlapping = tsk_malloc(self->max_overlapping * sizeof(*self->overlapping));\n if (self->overlapping == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int\nsegment_overlapper_free(segment_overlapper_t *self)\n{\n tsk_safe_free(self->overlapping);\n return 0;\n}\n\n/* Initialise the segment overlapper for use. Note that the segments\n * array must have space for num_segments + 1 elements!\n */\nstatic int TSK_WARN_UNUSED\nsegment_overlapper_start(\n segment_overlapper_t *self, tsk_segment_t *segments, tsk_size_t num_segments)\n{\n int ret = 0;\n tsk_segment_t *sentinel;\n void *p;\n\n if (self->max_overlapping < num_segments) {\n self->max_overlapping = num_segments;\n p = tsk_realloc(\n self->overlapping, self->max_overlapping * sizeof(*self->overlapping));\n if (p == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n self->overlapping = p;\n }\n self->segments = segments;\n self->num_segments = num_segments;\n self->index = 0;\n self->num_overlapping = 0;\n self->left = 0;\n self->right = DBL_MAX;\n\n /* Sort the segments in the buffer by left coordinate */\n qsort(\n self->segments, (size_t) self->num_segments, sizeof(tsk_segment_t), cmp_segment);\n /* NOTE! We are assuming that there's space for another element on the end\n * here. This is to insert a sentinel which simplifies the logic. */\n sentinel = self->segments + self->num_segments;\n sentinel->left = DBL_MAX;\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\nsegment_overlapper_next(segment_overlapper_t *self, double *left, double *right,\n tsk_segment_t ***overlapping, tsk_size_t *num_overlapping)\n{\n int ret = 0;\n tsk_size_t j, k;\n tsk_size_t n = self->num_segments;\n tsk_segment_t *S = self->segments;\n\n if (self->index < n) {\n self->left = self->right;\n /* Remove any elements of X with right <= left */\n k = 0;\n for (j = 0; j < self->num_overlapping; j++) {\n if (self->overlapping[j]->right > self->left) {\n self->overlapping[k] = self->overlapping[j];\n k++;\n }\n }\n self->num_overlapping = k;\n if (k == 0) {\n self->left = S[self->index].left;\n }\n while (self->index < n && S[self->index].left == self->left) {\n tsk_bug_assert(self->num_overlapping < self->max_overlapping);\n self->overlapping[self->num_overlapping] = &S[self->index];\n self->num_overlapping++;\n self->index++;\n }\n self->index--;\n self->right = S[self->index + 1].left;\n for (j = 0; j < self->num_overlapping; j++) {\n self->right = TSK_MIN(self->right, self->overlapping[j]->right);\n }\n tsk_bug_assert(self->left < self->right);\n self->index++;\n ret = 1;\n } else {\n self->left = self->right;\n self->right = DBL_MAX;\n k = 0;\n for (j = 0; j < self->num_overlapping; j++) {\n if (self->overlapping[j]->right > self->left) {\n self->right = TSK_MIN(self->right, self->overlapping[j]->right);\n self->overlapping[k] = self->overlapping[j];\n k++;\n }\n }\n self->num_overlapping = k;\n if (k > 0) {\n ret = 1;\n }\n }\n\n *left = self->left;\n *right = self->right;\n *overlapping = self->overlapping;\n *num_overlapping = self->num_overlapping;\n return ret;\n}\n\nstatic int\ncmp_node_id(const void *a, const void *b)\n{\n const tsk_id_t *ia = (const tsk_id_t *) a;\n const tsk_id_t *ib = (const tsk_id_t *) b;\n return (*ia > *ib) - (*ia < *ib);\n}\n\n/*************************\n * Ancestor mapper\n *************************/\n\n/* NOTE: this struct shares a lot with the simplifier_t, mostly in\n * terms of infrastructure for managing the list of intervals, saving\n * edges etc. We should try to abstract the common functionality out\n * into a separate class, which handles this.\n */\ntypedef struct {\n tsk_id_t *samples;\n tsk_size_t num_samples;\n tsk_id_t *ancestors;\n tsk_size_t num_ancestors;\n tsk_table_collection_t *tables;\n tsk_edge_table_t *result;\n tsk_segment_t **ancestor_map_head;\n tsk_segment_t **ancestor_map_tail;\n bool *is_sample;\n bool *is_ancestor;\n tsk_segment_t *segment_queue;\n tsk_size_t segment_queue_size;\n tsk_size_t max_segment_queue_size;\n segment_overlapper_t segment_overlapper;\n tsk_blkalloc_t segment_heap;\n tsk_blkalloc_t interval_list_heap;\n interval_list_t **child_edge_map_head;\n interval_list_t **child_edge_map_tail;\n tsk_id_t *buffered_children;\n tsk_size_t num_buffered_children;\n double sequence_length;\n double oldest_node_time;\n} ancestor_mapper_t;\n\nstatic tsk_segment_t *TSK_WARN_UNUSED\nancestor_mapper_alloc_segment(\n ancestor_mapper_t *self, double left, double right, tsk_id_t node)\n{\n tsk_segment_t *seg = NULL;\n\n seg = tsk_blkalloc_get(&self->segment_heap, sizeof(*seg));\n if (seg == NULL) {\n goto out;\n }\n seg->next = NULL;\n seg->left = left;\n seg->right = right;\n seg->node = node;\nout:\n return seg;\n}\n\nstatic interval_list_t *TSK_WARN_UNUSED\nancestor_mapper_alloc_interval_list(ancestor_mapper_t *self, double left, double right)\n{\n interval_list_t *x = NULL;\n\n x = tsk_blkalloc_get(&self->interval_list_heap, sizeof(*x));\n if (x == NULL) {\n goto out;\n }\n x->next = NULL;\n x->left = left;\n x->right = right;\nout:\n return x;\n}\n\nstatic int\nancestor_mapper_flush_edges(\n ancestor_mapper_t *self, tsk_id_t parent, tsk_size_t *ret_num_edges)\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_id_t child;\n interval_list_t *x;\n tsk_size_t num_edges = 0;\n\n qsort(self->buffered_children, (size_t) self->num_buffered_children,\n sizeof(tsk_id_t), cmp_node_id);\n for (j = 0; j < self->num_buffered_children; j++) {\n child = self->buffered_children[j];\n for (x = self->child_edge_map_head[child]; x != NULL; x = x->next) {\n ret_id = tsk_edge_table_add_row(\n self->result, x->left, x->right, parent, child, NULL, 0);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n num_edges++;\n }\n self->child_edge_map_head[child] = NULL;\n self->child_edge_map_tail[child] = NULL;\n }\n self->num_buffered_children = 0;\n *ret_num_edges = num_edges;\n ret = tsk_blkalloc_reset(&self->interval_list_heap);\nout:\n return ret;\n}\n\nstatic int\nancestor_mapper_record_edge(\n ancestor_mapper_t *self, double left, double right, tsk_id_t child)\n{\n int ret = 0;\n interval_list_t *tail, *x;\n\n tail = self->child_edge_map_tail[child];\n if (tail == NULL) {\n tsk_bug_assert(self->num_buffered_children < self->tables->nodes.num_rows);\n self->buffered_children[self->num_buffered_children] = child;\n self->num_buffered_children++;\n x = ancestor_mapper_alloc_interval_list(self, left, right);\n if (x == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n self->child_edge_map_head[child] = x;\n self->child_edge_map_tail[child] = x;\n } else {\n if (tail->right == left) {\n tail->right = right;\n } else {\n x = ancestor_mapper_alloc_interval_list(self, left, right);\n if (x == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tail->next = x;\n self->child_edge_map_tail[child] = x;\n }\n }\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\nancestor_mapper_add_ancestry(ancestor_mapper_t *self, tsk_id_t input_id, double left,\n double right, tsk_id_t output_id)\n{\n int ret = 0;\n tsk_segment_t *tail = self->ancestor_map_tail[input_id];\n tsk_segment_t *x;\n\n tsk_bug_assert(left < right);\n if (tail == NULL) {\n x = ancestor_mapper_alloc_segment(self, left, right, output_id);\n if (x == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n self->ancestor_map_head[input_id] = x;\n self->ancestor_map_tail[input_id] = x;\n } else {\n if (tail->right == left && tail->node == output_id) {\n tail->right = right;\n } else {\n x = ancestor_mapper_alloc_segment(self, left, right, output_id);\n if (x == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tail->next = x;\n self->ancestor_map_tail[input_id] = x;\n }\n }\nout:\n return ret;\n}\n\nstatic void\nancestor_mapper_find_oldest_node(ancestor_mapper_t *self)\n{\n const double *node_time = self->tables->nodes.time;\n tsk_size_t j;\n double max_time = -1;\n\n for (j = 0; j < self->num_ancestors; j++) {\n max_time = TSK_MAX(max_time, node_time[self->ancestors[j]]);\n }\n for (j = 0; j < self->num_samples; j++) {\n max_time = TSK_MAX(max_time, node_time[self->samples[j]]);\n }\n\n self->oldest_node_time = max_time;\n}\n\nstatic int\nancestor_mapper_init_samples(ancestor_mapper_t *self, tsk_id_t *samples)\n{\n int ret = 0;\n tsk_size_t j;\n\n /* Go through the samples to check for errors. */\n for (j = 0; j < self->num_samples; j++) {\n if (samples[j] < 0 || samples[j] > (tsk_id_t) self->tables->nodes.num_rows) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n if (self->is_sample[samples[j]]) {\n ret = tsk_trace_error(TSK_ERR_DUPLICATE_SAMPLE);\n goto out;\n }\n self->is_sample[samples[j]] = true;\n ret = ancestor_mapper_add_ancestry(\n self, samples[j], 0, self->tables->sequence_length, samples[j]);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int\nancestor_mapper_init_ancestors(ancestor_mapper_t *self, tsk_id_t *ancestors)\n{\n int ret = 0;\n tsk_size_t j;\n\n /* Go through the samples to check for errors. */\n for (j = 0; j < self->num_ancestors; j++) {\n if (ancestors[j] < 0 || ancestors[j] > (tsk_id_t) self->tables->nodes.num_rows) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n if (self->is_ancestor[ancestors[j]]) {\n ret = tsk_trace_error(TSK_ERR_DUPLICATE_SAMPLE);\n goto out;\n }\n self->is_ancestor[ancestors[j]] = true;\n }\nout:\n return ret;\n}\n\nstatic int\nancestor_mapper_init(ancestor_mapper_t *self, tsk_id_t *samples, tsk_size_t num_samples,\n tsk_id_t *ancestors, tsk_size_t num_ancestors, tsk_table_collection_t *tables,\n tsk_edge_table_t *result)\n{\n int ret = 0;\n tsk_size_t num_nodes;\n\n tsk_memset(self, 0, sizeof(ancestor_mapper_t));\n self->num_samples = num_samples;\n self->num_ancestors = num_ancestors;\n self->samples = samples;\n self->ancestors = ancestors;\n self->tables = tables;\n self->result = result;\n self->sequence_length = self->tables->sequence_length;\n\n if (samples == NULL || num_samples == 0 || ancestors == NULL || num_ancestors == 0) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n\n /* Allocate the heaps used for small objects-> Assuming 8K is a good chunk size\n */\n ret = tsk_blkalloc_init(&self->segment_heap, 8192);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_blkalloc_init(&self->interval_list_heap, 8192);\n if (ret != 0) {\n goto out;\n }\n ret = segment_overlapper_alloc(&self->segment_overlapper);\n if (ret != 0) {\n goto out;\n }\n\n num_nodes = tables->nodes.num_rows;\n /* Make the maps and set the intial state */\n self->ancestor_map_head = tsk_calloc(num_nodes, sizeof(tsk_segment_t *));\n self->ancestor_map_tail = tsk_calloc(num_nodes, sizeof(tsk_segment_t *));\n self->child_edge_map_head = tsk_calloc(num_nodes, sizeof(interval_list_t *));\n self->child_edge_map_tail = tsk_calloc(num_nodes, sizeof(interval_list_t *));\n self->buffered_children = tsk_malloc(num_nodes * sizeof(tsk_id_t));\n self->is_sample = tsk_calloc(num_nodes, sizeof(bool));\n self->is_ancestor = tsk_calloc(num_nodes, sizeof(bool));\n self->max_segment_queue_size = 64;\n self->segment_queue\n = tsk_malloc(self->max_segment_queue_size * sizeof(tsk_segment_t));\n if (self->ancestor_map_head == NULL || self->ancestor_map_tail == NULL\n || self->child_edge_map_head == NULL || self->child_edge_map_tail == NULL\n || self->is_sample == NULL || self->is_ancestor == NULL\n || self->segment_queue == NULL || self->buffered_children == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n // Clear memory.\n ret = ancestor_mapper_init_samples(self, samples);\n if (ret != 0) {\n goto out;\n }\n ret = ancestor_mapper_init_ancestors(self, ancestors);\n if (ret != 0) {\n goto out;\n }\n ancestor_mapper_find_oldest_node(self);\n ret = tsk_edge_table_clear(self->result);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int\nancestor_mapper_free(ancestor_mapper_t *self)\n{\n tsk_blkalloc_free(&self->segment_heap);\n tsk_blkalloc_free(&self->interval_list_heap);\n segment_overlapper_free(&self->segment_overlapper);\n tsk_safe_free(self->ancestor_map_head);\n tsk_safe_free(self->ancestor_map_tail);\n tsk_safe_free(self->child_edge_map_head);\n tsk_safe_free(self->child_edge_map_tail);\n tsk_safe_free(self->segment_queue);\n tsk_safe_free(self->is_sample);\n tsk_safe_free(self->is_ancestor);\n tsk_safe_free(self->buffered_children);\n return 0;\n}\n\nstatic int TSK_WARN_UNUSED\nancestor_mapper_enqueue_segment(\n ancestor_mapper_t *self, double left, double right, tsk_id_t node)\n{\n int ret = 0;\n tsk_segment_t *seg;\n void *p;\n\n tsk_bug_assert(left < right);\n /* Make sure we always have room for one more segment in the queue so we\n * can put a tail sentinel on it */\n if (self->segment_queue_size == self->max_segment_queue_size - 1) {\n self->max_segment_queue_size *= 2;\n p = tsk_realloc(self->segment_queue,\n self->max_segment_queue_size * sizeof(*self->segment_queue));\n if (p == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n self->segment_queue = p;\n }\n seg = self->segment_queue + self->segment_queue_size;\n seg->left = left;\n seg->right = right;\n seg->node = node;\n self->segment_queue_size++;\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\nancestor_mapper_merge_ancestors(ancestor_mapper_t *self, tsk_id_t input_id)\n{\n int ret = 0;\n tsk_segment_t **X, *x;\n tsk_size_t j, num_overlapping, num_flushed_edges;\n double left, right, prev_right;\n bool is_sample = self->is_sample[input_id];\n bool is_ancestor = self->is_ancestor[input_id];\n\n if (is_sample) {\n /* Free up the existing ancestry mapping. */\n x = self->ancestor_map_tail[input_id];\n tsk_bug_assert(x->left == 0 && x->right == self->sequence_length);\n self->ancestor_map_head[input_id] = NULL;\n self->ancestor_map_tail[input_id] = NULL;\n }\n ret = segment_overlapper_start(\n &self->segment_overlapper, self->segment_queue, self->segment_queue_size);\n if (ret != 0) {\n goto out;\n }\n\n prev_right = 0;\n while ((ret = segment_overlapper_next(\n &self->segment_overlapper, &left, &right, &X, &num_overlapping))\n == 1) {\n tsk_bug_assert(left < right);\n tsk_bug_assert(num_overlapping > 0);\n if (is_ancestor || is_sample) {\n for (j = 0; j < num_overlapping; j++) {\n ret = ancestor_mapper_record_edge(self, left, right, X[j]->node);\n if (ret != 0) {\n goto out;\n }\n }\n ret = ancestor_mapper_add_ancestry(self, input_id, left, right, input_id);\n if (ret != 0) {\n goto out;\n }\n if (is_sample && left != prev_right) {\n /* Fill in any gaps in ancestry for the sample */\n ret = ancestor_mapper_add_ancestry(\n self, input_id, prev_right, left, input_id);\n if (ret != 0) {\n goto out;\n }\n }\n } else {\n for (j = 0; j < num_overlapping; j++) {\n ret = ancestor_mapper_add_ancestry(\n self, input_id, left, right, X[j]->node);\n if (ret != 0) {\n goto out;\n }\n }\n }\n prev_right = right;\n }\n if (is_sample && prev_right != self->tables->sequence_length) {\n /* If a trailing gap exists in the sample ancestry, fill it in. */\n ret = ancestor_mapper_add_ancestry(\n self, input_id, prev_right, self->sequence_length, input_id);\n if (ret != 0) {\n goto out;\n }\n }\n if (input_id != TSK_NULL) {\n ret = ancestor_mapper_flush_edges(self, input_id, &num_flushed_edges);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\nancestor_mapper_process_parent_edges(\n ancestor_mapper_t *self, tsk_id_t parent, tsk_size_t start, tsk_size_t end)\n{\n int ret = 0;\n tsk_size_t j;\n tsk_segment_t *x;\n const tsk_edge_table_t *input_edges = &self->tables->edges;\n tsk_id_t child;\n double left, right;\n\n /* Go through the edges and queue up ancestry segments for processing. */\n self->segment_queue_size = 0;\n for (j = start; j < end; j++) {\n tsk_bug_assert(parent == input_edges->parent[j]);\n child = input_edges->child[j];\n left = input_edges->left[j];\n right = input_edges->right[j];\n // printf(\"C: %i, L: %f, R: %f\\n\", child, left, right);\n for (x = self->ancestor_map_head[child]; x != NULL; x = x->next) {\n if (x->right > left && right > x->left) {\n ret = ancestor_mapper_enqueue_segment(\n self, TSK_MAX(x->left, left), TSK_MIN(x->right, right), x->node);\n if (ret != 0) {\n goto out;\n }\n }\n }\n }\n // We can now merge the ancestral segments for the parent\n ret = ancestor_mapper_merge_ancestors(self, parent);\n if (ret != 0) {\n goto out;\n }\n\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\nancestor_mapper_run(ancestor_mapper_t *self)\n{\n int ret = 0;\n tsk_size_t j, start;\n tsk_id_t parent, current_parent;\n const tsk_edge_table_t *input_edges = &self->tables->edges;\n tsk_size_t num_edges = input_edges->num_rows;\n const double *node_time = self->tables->nodes.time;\n bool early_exit = false;\n\n if (num_edges > 0) {\n start = 0;\n current_parent = input_edges->parent[0];\n for (j = 0; j < num_edges; j++) {\n parent = input_edges->parent[j];\n if (parent != current_parent) {\n ret = ancestor_mapper_process_parent_edges(\n self, current_parent, start, j);\n if (ret != 0) {\n goto out;\n }\n start = j;\n current_parent = parent;\n if (node_time[current_parent] > self->oldest_node_time) {\n early_exit = true;\n break;\n }\n }\n }\n if (!early_exit) {\n /* If we didn't break out of the loop early, we need to still process\n * the final parent */\n ret = ancestor_mapper_process_parent_edges(self, current_parent, start, j);\n if (ret != 0) {\n goto out;\n }\n }\n }\nout:\n return ret;\n}\n\n/*************************\n * IBD Segments\n *************************/\n\n/* This maps two positive integers 0 <= a < b < N into the set\n * {0, ..., N^2}. For us to overflow an int64, N would need to\n * be > sqrt(2^63), ~3 * 10^9. The maximum value for a 32bit int\n * is ~2 * 10^9, so this can't happen here, however it is\n * theoretically possible with 64 bit IDs. It would require\n * a *very* large node table --- assuming 24 bytes per row\n * it would be at least 67GiB. To make sure this eventuality\n * doesn't happen, we have a tsk_bug_assert in the\n * tsk_identity_segments_init.\n */\nstatic inline int64_t\npair_to_integer(tsk_id_t a, tsk_id_t b, tsk_size_t N)\n{\n tsk_id_t tmp;\n if (a > b) {\n tmp = a;\n a = b;\n b = tmp;\n }\n return ((int64_t) a) * (int64_t) N + (int64_t) b;\n}\n\nstatic inline void\ninteger_to_pair(int64_t index, tsk_size_t N, tsk_id_t *a, tsk_id_t *b)\n{\n *a = (tsk_id_t) (index / (int64_t) N);\n *b = (tsk_id_t) (index % (int64_t) N);\n}\n\nstatic int64_t\ntsk_identity_segments_get_key(\n const tsk_identity_segments_t *self, tsk_id_t a, tsk_id_t b)\n{\n int64_t ret;\n tsk_id_t N = (tsk_id_t) self->num_nodes;\n\n if (a < 0 || b < 0 || a >= N || b >= N) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n if (a == b) {\n ret = tsk_trace_error(TSK_ERR_SAME_NODES_IN_PAIR);\n goto out;\n }\n ret = pair_to_integer(a, b, self->num_nodes);\nout:\n return ret;\n}\n\nstatic tsk_identity_segment_t *TSK_WARN_UNUSED\ntsk_identity_segments_alloc_segment(\n tsk_identity_segments_t *self, double left, double right, tsk_id_t node)\n{\n tsk_identity_segment_t *seg = tsk_blkalloc_get(&self->heap, sizeof(*seg));\n if (seg == NULL) {\n goto out;\n }\n tsk_bug_assert(left < right);\n tsk_bug_assert(node >= 0 && node < (tsk_id_t) self->num_nodes);\n\n seg->next = NULL;\n seg->left = left;\n seg->right = right;\n seg->node = node;\nout:\n return seg;\n}\n\nstatic tsk_avl_node_int_t *\ntsk_identity_segments_alloc_new_pair(tsk_identity_segments_t *self, int64_t key)\n{\n tsk_avl_node_int_t *avl_node = tsk_blkalloc_get(&self->heap, sizeof(*avl_node));\n tsk_identity_segment_list_t *list = tsk_blkalloc_get(&self->heap, sizeof(*list));\n\n if (avl_node == NULL || list == NULL) {\n return NULL;\n }\n avl_node->key = key;\n avl_node->value = list;\n memset(list, 0, sizeof(*list));\n return avl_node;\n}\n\n/* Deliberately not making this a part of the public interface for now,\n * so we don't have to worry about the signature */\nstatic int\ntsk_identity_segments_init(\n tsk_identity_segments_t *self, tsk_size_t num_nodes, tsk_flags_t options)\n{\n int ret = 0;\n /* Make sure we don't overflow in the ID mapping. See the comments in pair_to_integer\n * for details. */\n double max_num_nodes = sqrt(1ULL << 63);\n tsk_bug_assert((double) num_nodes < max_num_nodes);\n\n memset(self, 0, sizeof(*self));\n self->num_nodes = num_nodes;\n /* Storing segments implies storing pairs */\n if (options & TSK_IBD_STORE_SEGMENTS) {\n self->store_pairs = true;\n self->store_segments = true;\n } else if (options & TSK_IBD_STORE_PAIRS) {\n self->store_pairs = true;\n }\n ret = tsk_avl_tree_int_init(&self->pair_map);\n if (ret != 0) {\n goto out;\n }\n /* Allocate heap memory in 1MiB blocks */\n ret = tsk_blkalloc_init(&self->heap, 1024 * 1024);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nvoid\ntsk_identity_segments_print_state(tsk_identity_segments_t *self, FILE *out)\n{\n tsk_avl_node_int_t **nodes = tsk_malloc(self->pair_map.size * sizeof(*nodes));\n int64_t key;\n tsk_identity_segment_list_t *value;\n tsk_identity_segment_t *seg;\n tsk_size_t j;\n tsk_id_t a, b;\n\n tsk_bug_assert(nodes != NULL);\n\n fprintf(out, \"===\\nIBD Result\\n===\\n\");\n fprintf(out, \"total_span = %f\\n\", self->total_span);\n fprintf(out, \"num_segments = %lld\\n\", (unsigned long long) self->num_segments);\n fprintf(out, \"store_pairs = %d\\n\", self->store_pairs);\n fprintf(out, \"store_segments = %d\\n\", self->store_segments);\n if (self->store_pairs) {\n fprintf(out, \"num_keys = %d\\n\", (int) self->pair_map.size);\n tsk_avl_tree_int_ordered_nodes(&self->pair_map, nodes);\n for (j = 0; j < self->pair_map.size; j++) {\n key = nodes[j]->key;\n value = (tsk_identity_segment_list_t *) nodes[j]->value;\n integer_to_pair(key, self->num_nodes, &a, &b);\n fprintf(out, \"%lld\\t(%d,%d) n=%d total_span=%f\\t\", (long long) key, (int) a,\n (int) b, (int) value->num_segments, value->total_span);\n if (self->store_segments) {\n for (seg = value->head; seg != NULL; seg = seg->next) {\n fprintf(\n out, \"(%f, %f)->%d, \", seg->left, seg->right, (int) seg->node);\n }\n }\n fprintf(out, \"\\n\");\n }\n }\n fprintf(out, \"Segment memory\\n\");\n tsk_blkalloc_print_state(&self->heap, out);\n tsk_safe_free(nodes);\n}\n\ntsk_size_t\ntsk_identity_segments_get_num_segments(const tsk_identity_segments_t *self)\n{\n return self->num_segments;\n}\n\ndouble\ntsk_identity_segments_get_total_span(const tsk_identity_segments_t *self)\n{\n return self->total_span;\n}\n\ntsk_size_t\ntsk_identity_segments_get_num_pairs(const tsk_identity_segments_t *self)\n{\n return self->pair_map.size;\n}\n\n/* Use an inorder traversal on the AVL tree to get the pairs in order.\n * Recursion is safe here because it's a balanced tree (see the AVL tree\n * code for notes on this).\n */\nstatic int\nget_keys_traverse(tsk_avl_node_int_t *node, int index, tsk_size_t N, tsk_id_t *pairs)\n{\n tsk_id_t a, b;\n\n if (node == NULL) {\n return index;\n }\n index = get_keys_traverse(node->llink, index, N, pairs);\n integer_to_pair(node->key, N, &a, &b);\n pairs[2 * index] = a;\n pairs[2 * index + 1] = b;\n return get_keys_traverse(node->rlink, index + 1, N, pairs);\n}\n\nint\ntsk_identity_segments_get_keys(const tsk_identity_segments_t *self, tsk_id_t *pairs)\n{\n if (!self->store_pairs) {\n return TSK_ERR_IBD_PAIRS_NOT_STORED;\n }\n get_keys_traverse(\n tsk_avl_tree_int_get_root(&self->pair_map), 0, self->num_nodes, pairs);\n return 0;\n}\n\nstatic int\nget_items_traverse(tsk_avl_node_int_t *node, int index, tsk_size_t N, tsk_id_t *pairs,\n tsk_identity_segment_list_t **lists)\n{\n tsk_id_t a, b;\n\n if (node == NULL) {\n return index;\n }\n index = get_items_traverse(node->llink, index, N, pairs, lists);\n integer_to_pair(node->key, N, &a, &b);\n pairs[2 * index] = a;\n pairs[2 * index + 1] = b;\n lists[index] = node->value;\n return get_items_traverse(node->rlink, index + 1, N, pairs, lists);\n}\n\nint\ntsk_identity_segments_get_items(const tsk_identity_segments_t *self, tsk_id_t *pairs,\n tsk_identity_segment_list_t **lists)\n{\n if (!self->store_pairs) {\n return TSK_ERR_IBD_PAIRS_NOT_STORED;\n }\n get_items_traverse(\n tsk_avl_tree_int_get_root(&self->pair_map), 0, self->num_nodes, pairs, lists);\n return 0;\n}\n\nint\ntsk_identity_segments_free(tsk_identity_segments_t *self)\n{\n tsk_blkalloc_free(&self->heap);\n tsk_avl_tree_int_free(&self->pair_map);\n return 0;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_identity_segments_update_pair(tsk_identity_segments_t *self, tsk_id_t a, tsk_id_t b,\n double left, double right, tsk_id_t node)\n{\n int ret = 0;\n tsk_identity_segment_t *x;\n tsk_identity_segment_list_t *list;\n /* skip the error checking here since this an internal API */\n int64_t key = pair_to_integer(a, b, self->num_nodes);\n tsk_avl_node_int_t *avl_node = tsk_avl_tree_int_search(&self->pair_map, key);\n\n if (avl_node == NULL) {\n /* We haven't seen this pair before */\n avl_node = tsk_identity_segments_alloc_new_pair(self, key);\n if (avl_node == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n ret = tsk_avl_tree_int_insert(&self->pair_map, avl_node);\n tsk_bug_assert(ret == 0);\n }\n list = (tsk_identity_segment_list_t *) avl_node->value;\n list->num_segments++;\n list->total_span += right - left;\n if (self->store_segments) {\n x = tsk_identity_segments_alloc_segment(self, left, right, node);\n if (x == NULL) {\n goto out;\n }\n if (list->tail == NULL) {\n list->head = x;\n list->tail = x;\n } else {\n list->tail->next = x;\n list->tail = x;\n }\n }\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_identity_segments_add_segment(tsk_identity_segments_t *self, tsk_id_t a, tsk_id_t b,\n double left, double right, tsk_id_t node)\n{\n int ret = 0;\n\n if (self->store_pairs) {\n ret = tsk_identity_segments_update_pair(self, a, b, left, right, node);\n if (ret != 0) {\n goto out;\n }\n }\n self->total_span += right - left;\n self->num_segments++;\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_identity_segments_get(const tsk_identity_segments_t *self, tsk_id_t sample_a,\n tsk_id_t sample_b, tsk_identity_segment_list_t **ret_list)\n{\n int ret = 0;\n int64_t key = tsk_identity_segments_get_key(self, sample_a, sample_b);\n tsk_avl_node_int_t *avl_node;\n\n if (key < 0) {\n ret = (int) key;\n goto out;\n }\n if (!self->store_pairs) {\n ret = tsk_trace_error(TSK_ERR_IBD_PAIRS_NOT_STORED);\n goto out;\n }\n avl_node = tsk_avl_tree_int_search(&self->pair_map, key);\n *ret_list = NULL;\n if (avl_node != NULL) {\n *ret_list = (tsk_identity_segment_list_t *) avl_node->value;\n }\nout:\n return ret;\n}\n\n/*************************\n * IBD finder\n *************************/\n\ntypedef struct {\n tsk_identity_segments_t *result;\n double min_span;\n double max_time;\n const tsk_table_collection_t *tables;\n /* Maps nodes to their sample set IDs. Input samples map to set 0\n * in the \"within\" case. */\n tsk_id_t *sample_set_id;\n /* True if we're finding IBD between sample sets, false otherwise. */\n bool finding_between;\n tsk_segment_t **ancestor_map_head;\n tsk_segment_t **ancestor_map_tail;\n tsk_segment_t *segment_queue;\n tsk_size_t segment_queue_size;\n tsk_size_t max_segment_queue_size;\n tsk_blkalloc_t segment_heap;\n} tsk_ibd_finder_t;\n\nstatic tsk_segment_t *TSK_WARN_UNUSED\ntsk_ibd_finder_alloc_segment(\n tsk_ibd_finder_t *self, double left, double right, tsk_id_t node)\n{\n tsk_segment_t *seg = NULL;\n\n seg = tsk_blkalloc_get(&self->segment_heap, sizeof(*seg));\n if (seg == NULL) {\n goto out;\n }\n seg->next = NULL;\n seg->left = left;\n seg->right = right;\n seg->node = node;\n\nout:\n return seg;\n}\nstatic int TSK_WARN_UNUSED\ntsk_ibd_finder_add_ancestry(tsk_ibd_finder_t *self, tsk_id_t input_id, double left,\n double right, tsk_id_t output_id)\n{\n int ret = 0;\n tsk_segment_t *tail = self->ancestor_map_tail[input_id];\n tsk_segment_t *x = NULL;\n\n tsk_bug_assert(left < right);\n x = tsk_ibd_finder_alloc_segment(self, left, right, output_id);\n if (x == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n if (tail == NULL) {\n self->ancestor_map_head[input_id] = x;\n self->ancestor_map_tail[input_id] = x;\n } else {\n tail->next = x;\n self->ancestor_map_tail[input_id] = x;\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_ibd_finder_init_samples_from_set(\n tsk_ibd_finder_t *self, const tsk_id_t *samples, tsk_size_t num_samples)\n{\n int ret = 0;\n tsk_size_t j;\n tsk_id_t u;\n\n for (j = 0; j < num_samples; j++) {\n u = samples[j];\n\n if (u < 0 || u > (tsk_id_t) self->tables->nodes.num_rows) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n if (self->sample_set_id[u] != TSK_NULL) {\n ret = tsk_trace_error(TSK_ERR_DUPLICATE_SAMPLE);\n goto out;\n }\n self->sample_set_id[u] = 0;\n }\nout:\n return ret;\n}\n\nstatic void\ntsk_ibd_finder_init_samples_from_nodes(tsk_ibd_finder_t *self)\n{\n tsk_id_t u;\n const tsk_id_t num_nodes = (tsk_id_t) self->tables->nodes.num_rows;\n const tsk_flags_t *restrict flags = self->tables->nodes.flags;\n\n for (u = 0; u < num_nodes; u++) {\n if (flags[u] & TSK_NODE_IS_SAMPLE) {\n self->sample_set_id[u] = 0;\n }\n }\n}\n\nstatic int\ntsk_ibd_finder_add_sample_ancestry(tsk_ibd_finder_t *self)\n{\n\n int ret = 0;\n tsk_id_t u;\n const tsk_id_t num_nodes = (tsk_id_t) self->tables->nodes.num_rows;\n const double L = self->tables->sequence_length;\n\n for (u = 0; u < num_nodes; u++) {\n if (self->sample_set_id[u] != TSK_NULL) {\n ret = tsk_ibd_finder_add_ancestry(self, u, 0, L, u);\n if (ret != 0) {\n goto out;\n }\n }\n }\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_ibd_finder_init(tsk_ibd_finder_t *self, const tsk_table_collection_t *tables,\n tsk_identity_segments_t *result, double min_span, double max_time)\n{\n int ret = 0;\n tsk_size_t num_nodes;\n\n tsk_memset(self, 0, sizeof(tsk_ibd_finder_t));\n\n if (min_span < 0) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if (max_time < 0) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n\n self->tables = tables;\n self->result = result;\n self->max_time = max_time;\n self->min_span = min_span;\n\n ret = tsk_blkalloc_init(&self->segment_heap, 8192);\n if (ret != 0) {\n goto out;\n }\n\n num_nodes = tables->nodes.num_rows;\n self->ancestor_map_head = tsk_calloc(num_nodes, sizeof(*self->ancestor_map_head));\n self->ancestor_map_tail = tsk_calloc(num_nodes, sizeof(*self->ancestor_map_tail));\n self->sample_set_id = tsk_malloc(num_nodes * sizeof(*self->sample_set_id));\n self->segment_queue_size = 0;\n self->max_segment_queue_size = 64;\n self->segment_queue\n = tsk_malloc(self->max_segment_queue_size * sizeof(*self->segment_queue));\n if (self->ancestor_map_head == NULL || self->ancestor_map_tail == NULL\n || self->sample_set_id == NULL || self->segment_queue == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(self->sample_set_id, TSK_NULL, num_nodes * sizeof(*self->sample_set_id));\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_ibd_finder_enqueue_segment(\n tsk_ibd_finder_t *self, double left, double right, tsk_id_t node)\n{\n int ret = 0;\n tsk_segment_t *seg;\n void *p;\n\n if ((right - left) > self->min_span) {\n /* Make sure we always have room for one more segment in the queue so we\n * can put a tail sentinel on it */\n if (self->segment_queue_size == self->max_segment_queue_size - 1) {\n self->max_segment_queue_size *= 2;\n p = tsk_realloc(self->segment_queue,\n self->max_segment_queue_size * sizeof(*self->segment_queue));\n if (p == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n self->segment_queue = p;\n }\n seg = self->segment_queue + self->segment_queue_size;\n seg->left = left;\n seg->right = right;\n seg->node = node;\n self->segment_queue_size++;\n }\nout:\n return ret;\n}\n\nstatic bool\ntsk_ibd_finder_passes_filters(\n const tsk_ibd_finder_t *self, tsk_id_t a, tsk_id_t b, double left, double right)\n{\n if (a == b) {\n return false;\n }\n if ((right - left) <= self->min_span) {\n return false;\n }\n if (self->finding_between) {\n return self->sample_set_id[a] != self->sample_set_id[b];\n } else {\n return true;\n }\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_ibd_finder_record_ibd(tsk_ibd_finder_t *self, tsk_id_t parent)\n{\n int ret = 0;\n tsk_size_t j;\n tsk_segment_t *seg0, *seg1;\n double left, right;\n\n for (seg0 = self->ancestor_map_head[parent]; seg0 != NULL; seg0 = seg0->next) {\n for (j = 0; j < self->segment_queue_size; j++) {\n seg1 = &self->segment_queue[j];\n left = TSK_MAX(seg0->left, seg1->left);\n right = TSK_MIN(seg0->right, seg1->right);\n if (tsk_ibd_finder_passes_filters(\n self, seg0->node, seg1->node, left, right)) {\n ret = tsk_identity_segments_add_segment(\n self->result, seg0->node, seg1->node, left, right, parent);\n if (ret != 0) {\n goto out;\n }\n }\n }\n }\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_ibd_finder_add_queued_ancestry(tsk_ibd_finder_t *self, tsk_id_t parent)\n{\n int ret = 0;\n tsk_size_t j;\n tsk_segment_t seg;\n\n for (j = 0; j < self->segment_queue_size; j++) {\n seg = self->segment_queue[j];\n ret = tsk_ibd_finder_add_ancestry(self, parent, seg.left, seg.right, seg.node);\n if (ret != 0) {\n goto out;\n }\n }\n self->segment_queue_size = 0;\nout:\n return ret;\n}\n\nstatic void\ntsk_ibd_finder_print_state(tsk_ibd_finder_t *self, FILE *out)\n{\n tsk_size_t j;\n tsk_segment_t *u = NULL;\n\n fprintf(out, \"--ibd-finder stats--\\n\");\n fprintf(out, \"max_time = %f\\n\", self->max_time);\n fprintf(out, \"min_span = %f\\n\", self->min_span);\n fprintf(out, \"finding_between = %d\\n\", self->finding_between);\n fprintf(out, \"===\\nEdges\\n===\\n\");\n for (j = 0; j < self->tables->edges.num_rows; j++) {\n fprintf(out, \"L:%f, R:%f, P:%lld, C:%lld\\n\", self->tables->edges.left[j],\n self->tables->edges.right[j], (long long) self->tables->edges.parent[j],\n (long long) self->tables->edges.child[j]);\n }\n fprintf(out, \"===\\nNodes\\n===\\n\");\n for (j = 0; j < self->tables->nodes.num_rows; j++) {\n fprintf(out, \"ID:%d, Time:%f, Flag:%lld Sample set:%d\\n\", (int) j,\n self->tables->nodes.time[j], (long long) self->tables->nodes.flags[j],\n (int) self->sample_set_id[j]);\n }\n fprintf(out, \"===\\nAncestral map\\n===\\n\");\n for (j = 0; j < self->tables->nodes.num_rows; j++) {\n fprintf(out, \"Node %lld: \", (long long) j);\n for (u = self->ancestor_map_head[j]; u != NULL; u = u->next) {\n fprintf(out, \"(%f,%f->%lld)\", u->left, u->right, (long long) u->node);\n }\n fprintf(out, \"\\n\");\n }\n tsk_identity_segments_print_state(self->result, out);\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_ibd_finder_init_within(\n tsk_ibd_finder_t *self, const tsk_id_t *samples, tsk_size_t num_samples)\n{\n int ret;\n\n if (samples == NULL) {\n tsk_ibd_finder_init_samples_from_nodes(self);\n } else {\n ret = tsk_ibd_finder_init_samples_from_set(self, samples, num_samples);\n if (ret != 0) {\n goto out;\n }\n }\n self->finding_between = false;\n ret = tsk_ibd_finder_add_sample_ancestry(self);\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_ibd_finder_init_between(tsk_ibd_finder_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets)\n{\n int ret = 0;\n tsk_size_t j, k, index;\n tsk_id_t u;\n\n index = 0;\n for (j = 0; j < num_sample_sets; j++) {\n for (k = 0; k < sample_set_sizes[j]; k++) {\n u = sample_sets[index];\n if (u < 0 || u > (tsk_id_t) self->tables->nodes.num_rows) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n if (self->sample_set_id[u] != TSK_NULL) {\n ret = tsk_trace_error(TSK_ERR_DUPLICATE_SAMPLE);\n goto out;\n }\n self->sample_set_id[u] = (tsk_id_t) j;\n index++;\n }\n }\n self->finding_between = true;\n ret = tsk_ibd_finder_add_sample_ancestry(self);\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_ibd_finder_run(tsk_ibd_finder_t *self)\n{\n const tsk_edge_table_t *input_edges = &self->tables->edges;\n const tsk_size_t num_edges = input_edges->num_rows;\n int ret = 0;\n tsk_size_t j;\n tsk_segment_t *s;\n tsk_id_t parent, child;\n double left, right, intvl_l, intvl_r, time;\n\n for (j = 0; j < num_edges; j++) {\n parent = input_edges->parent[j];\n left = input_edges->left[j];\n right = input_edges->right[j];\n child = input_edges->child[j];\n time = self->tables->nodes.time[parent];\n if (time > self->max_time) {\n break;\n }\n\n for (s = self->ancestor_map_head[child]; s != NULL; s = s->next) {\n intvl_l = TSK_MAX(left, s->left);\n intvl_r = TSK_MIN(right, s->right);\n ret = tsk_ibd_finder_enqueue_segment(self, intvl_l, intvl_r, s->node);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_ibd_finder_record_ibd(self, parent);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_ibd_finder_add_queued_ancestry(self, parent);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_ibd_finder_free(tsk_ibd_finder_t *self)\n{\n tsk_blkalloc_free(&self->segment_heap);\n tsk_safe_free(self->sample_set_id);\n tsk_safe_free(self->ancestor_map_head);\n tsk_safe_free(self->ancestor_map_tail);\n tsk_safe_free(self->segment_queue);\n return 0;\n}\n\n/*************************\n * simplifier\n *************************/\n\nstatic void\nsimplifier_check_state(simplifier_t *self)\n{\n tsk_size_t j, k;\n tsk_segment_t *u;\n mutation_id_list_t *list_node;\n tsk_id_t site;\n interval_list_t *int_list;\n tsk_id_t child;\n double position, last_position;\n bool found;\n tsk_size_t num_intervals;\n\n for (j = 0; j < self->input_tables.nodes.num_rows; j++) {\n tsk_bug_assert((self->ancestor_map_head[j] == NULL)\n == (self->ancestor_map_tail[j] == NULL));\n for (u = self->ancestor_map_head[j]; u != NULL; u = u->next) {\n tsk_bug_assert(u->left < u->right);\n if (u->next != NULL) {\n tsk_bug_assert(u->right <= u->next->left);\n if (u->right == u->next->left) {\n tsk_bug_assert(u->node != u->next->node);\n }\n } else {\n tsk_bug_assert(u == self->ancestor_map_tail[j]);\n }\n }\n }\n\n for (j = 0; j < self->segment_queue_size; j++) {\n tsk_bug_assert(self->segment_queue[j].left < self->segment_queue[j].right);\n }\n\n for (j = 0; j < self->input_tables.nodes.num_rows; j++) {\n last_position = -1;\n for (list_node = self->node_mutation_list_map_head[j]; list_node != NULL;\n list_node = list_node->next) {\n tsk_bug_assert(\n self->input_tables.mutations.node[list_node->mutation] == (tsk_id_t) j);\n site = self->input_tables.mutations.site[list_node->mutation];\n position = self->input_tables.sites.position[site];\n tsk_bug_assert(last_position <= position);\n last_position = position;\n }\n }\n\n /* check the buffered edges */\n for (j = 0; j < self->input_tables.nodes.num_rows; j++) {\n tsk_bug_assert((self->child_edge_map_head[j] == NULL)\n == (self->child_edge_map_tail[j] == NULL));\n if (self->child_edge_map_head[j] != NULL) {\n /* Make sure that the child is in our list */\n found = false;\n for (k = 0; k < self->num_buffered_children; k++) {\n if (self->buffered_children[k] == (tsk_id_t) j) {\n found = true;\n break;\n }\n }\n tsk_bug_assert(found);\n }\n }\n num_intervals = 0;\n for (j = 0; j < self->num_buffered_children; j++) {\n child = self->buffered_children[j];\n tsk_bug_assert(self->child_edge_map_head[child] != NULL);\n for (int_list = self->child_edge_map_head[child]; int_list != NULL;\n int_list = int_list->next) {\n tsk_bug_assert(int_list->left < int_list->right);\n if (int_list->next != NULL) {\n tsk_bug_assert(int_list->right < int_list->next->left);\n }\n num_intervals++;\n }\n }\n tsk_bug_assert(\n num_intervals\n == self->interval_list_heap.total_allocated / (sizeof(interval_list_t)));\n}\n\nstatic void\nprint_segment_chain(tsk_segment_t *head, FILE *out)\n{\n tsk_segment_t *u;\n\n for (u = head; u != NULL; u = u->next) {\n fprintf(out, \"(%f,%f->%lld)\", u->left, u->right, (long long) u->node);\n }\n}\n\nstatic void\nsimplifier_print_state(simplifier_t *self, FILE *out)\n{\n tsk_size_t j;\n tsk_segment_t *u;\n mutation_id_list_t *list_node;\n interval_list_t *int_list;\n tsk_id_t child;\n\n fprintf(out, \"--simplifier state--\\n\");\n fprintf(out, \"options:\\n\");\n fprintf(out, \"\\tfilter_unreferenced_sites : %d\\n\",\n !!(self->options & TSK_SIMPLIFY_FILTER_SITES));\n fprintf(out, \"\\tno_filter_nodes : %d\\n\",\n !!(self->options & TSK_SIMPLIFY_NO_FILTER_NODES));\n fprintf(out, \"\\treduce_to_site_topology : %d\\n\",\n !!(self->options & TSK_SIMPLIFY_REDUCE_TO_SITE_TOPOLOGY));\n fprintf(out, \"\\tkeep_unary : %d\\n\",\n !!(self->options & TSK_SIMPLIFY_KEEP_UNARY));\n fprintf(out, \"\\tkeep_input_roots : %d\\n\",\n !!(self->options & TSK_SIMPLIFY_KEEP_INPUT_ROOTS));\n fprintf(out, \"\\tkeep_unary_in_individuals : %d\\n\",\n !!(self->options & TSK_SIMPLIFY_KEEP_UNARY_IN_INDIVIDUALS));\n\n fprintf(out, \"===\\nInput tables\\n==\\n\");\n tsk_table_collection_print_state(&self->input_tables, out);\n fprintf(out, \"===\\nOutput tables\\n==\\n\");\n tsk_table_collection_print_state(self->tables, out);\n fprintf(out, \"===\\nmemory heaps\\n==\\n\");\n fprintf(out, \"segment_heap:\\n\");\n tsk_blkalloc_print_state(&self->segment_heap, out);\n fprintf(out, \"interval_list_heap:\\n\");\n tsk_blkalloc_print_state(&self->interval_list_heap, out);\n fprintf(out, \"===\\nancestors\\n==\\n\");\n for (j = 0; j < self->input_tables.nodes.num_rows; j++) {\n fprintf(out, \"%lld:\\t\", (long long) j);\n print_segment_chain(self->ancestor_map_head[j], out);\n fprintf(out, \"\\n\");\n }\n fprintf(out, \"===\\nnode_id map (input->output)\\n==\\n\");\n for (j = 0; j < self->input_tables.nodes.num_rows; j++) {\n if (self->node_id_map[j] != TSK_NULL) {\n fprintf(\n out, \"%lld->%lld\\n\", (long long) j, (long long) self->node_id_map[j]);\n }\n }\n fprintf(out, \"===\\nsegment queue\\n==\\n\");\n for (j = 0; j < self->segment_queue_size; j++) {\n u = &self->segment_queue[j];\n fprintf(out, \"(%f,%f->%lld)\", u->left, u->right, (long long) u->node);\n fprintf(out, \"\\n\");\n }\n fprintf(out, \"===\\nbuffered children\\n==\\n\");\n for (j = 0; j < self->num_buffered_children; j++) {\n child = self->buffered_children[j];\n fprintf(out, \"%lld -> \", (long long) j);\n for (int_list = self->child_edge_map_head[child]; int_list != NULL;\n int_list = int_list->next) {\n fprintf(out, \"(%f, %f), \", int_list->left, int_list->right);\n }\n fprintf(out, \"\\n\");\n }\n fprintf(out, \"===\\nmutation node map\\n==\\n\");\n for (j = 0; j < self->input_tables.mutations.num_rows; j++) {\n fprintf(out, \"%lld\\t-> %lld\\n\", (long long) j,\n (long long) self->mutation_node_map[j]);\n }\n fprintf(out, \"===\\nnode mutation id list map\\n==\\n\");\n for (j = 0; j < self->input_tables.nodes.num_rows; j++) {\n if (self->node_mutation_list_map_head[j] != NULL) {\n fprintf(out, \"%lld\\t-> [\", (long long) j);\n for (list_node = self->node_mutation_list_map_head[j]; list_node != NULL;\n list_node = list_node->next) {\n fprintf(out, \"%lld,\", (long long) list_node->mutation);\n }\n fprintf(out, \"]\\n\");\n }\n }\n if (!!(self->options & TSK_SIMPLIFY_REDUCE_TO_SITE_TOPOLOGY)) {\n fprintf(out, \"===\\nposition_lookup\\n==\\n\");\n for (j = 0; j < self->input_tables.sites.num_rows + 2; j++) {\n fprintf(out, \"%lld\\t-> %f\\n\", (long long) j, self->position_lookup[j]);\n }\n }\n simplifier_check_state(self);\n}\n\nstatic tsk_segment_t *TSK_WARN_UNUSED\nsimplifier_alloc_segment(simplifier_t *self, double left, double right, tsk_id_t node)\n{\n tsk_segment_t *seg = NULL;\n\n seg = tsk_blkalloc_get(&self->segment_heap, sizeof(*seg));\n if (seg == NULL) {\n goto out;\n }\n seg->next = NULL;\n seg->left = left;\n seg->right = right;\n seg->node = node;\nout:\n return seg;\n}\n\nstatic interval_list_t *TSK_WARN_UNUSED\nsimplifier_alloc_interval_list(simplifier_t *self, double left, double right)\n{\n interval_list_t *x = NULL;\n\n x = tsk_blkalloc_get(&self->interval_list_heap, sizeof(*x));\n if (x == NULL) {\n goto out;\n }\n x->next = NULL;\n x->left = left;\n x->right = right;\nout:\n return x;\n}\n\n/* Add a new node to the output node table corresponding to the specified input id.\n * Returns the new ID. */\nstatic tsk_id_t TSK_WARN_UNUSED\nsimplifier_record_node(simplifier_t *self, tsk_id_t input_id)\n{\n tsk_node_t node;\n bool update_flags = !(self->options & TSK_SIMPLIFY_NO_UPDATE_SAMPLE_FLAGS);\n\n tsk_node_table_get_row_unsafe(&self->input_tables.nodes, (tsk_id_t) input_id, &node);\n if (update_flags) {\n /* Zero out the sample bit */\n node.flags &= (tsk_flags_t) ~TSK_NODE_IS_SAMPLE;\n if (self->is_sample[input_id]) {\n node.flags |= TSK_NODE_IS_SAMPLE;\n }\n }\n self->node_id_map[input_id] = (tsk_id_t) self->tables->nodes.num_rows;\n return tsk_node_table_add_row(&self->tables->nodes, node.flags, node.time,\n node.population, node.individual, node.metadata, node.metadata_length);\n}\n\n/* Remove the mapping for the last recorded node. */\nstatic int\nsimplifier_rewind_node(simplifier_t *self, tsk_id_t input_id, tsk_id_t output_id)\n{\n self->node_id_map[input_id] = TSK_NULL;\n return tsk_node_table_truncate(&self->tables->nodes, (tsk_size_t) output_id);\n}\n\nstatic int\nsimplifier_flush_edges(simplifier_t *self, tsk_id_t parent, tsk_size_t *ret_num_edges)\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_id_t child;\n interval_list_t *x;\n tsk_size_t num_edges = 0;\n\n qsort(self->buffered_children, (size_t) self->num_buffered_children,\n sizeof(tsk_id_t), cmp_node_id);\n for (j = 0; j < self->num_buffered_children; j++) {\n child = self->buffered_children[j];\n for (x = self->child_edge_map_head[child]; x != NULL; x = x->next) {\n ret_id = tsk_edge_table_add_row(\n &self->tables->edges, x->left, x->right, parent, child, NULL, 0);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n num_edges++;\n }\n self->child_edge_map_head[child] = NULL;\n self->child_edge_map_tail[child] = NULL;\n }\n self->num_buffered_children = 0;\n *ret_num_edges = num_edges;\n ret = tsk_blkalloc_reset(&self->interval_list_heap);\nout:\n return ret;\n}\n\n/* When we are reducing topology down to what is visible at the sites we need a\n * lookup table to find the closest site position for each edge. We do this with\n * a sorted array and binary search */\nstatic int\nsimplifier_init_position_lookup(simplifier_t *self)\n{\n int ret = 0;\n tsk_size_t num_sites = self->input_tables.sites.num_rows;\n\n self->position_lookup = tsk_malloc((num_sites + 2) * sizeof(*self->position_lookup));\n if (self->position_lookup == NULL) {\n goto out;\n }\n self->position_lookup[0] = 0;\n self->position_lookup[num_sites + 1] = self->input_tables.sequence_length;\n tsk_memcpy(self->position_lookup + 1, self->input_tables.sites.position,\n num_sites * sizeof(double));\nout:\n return ret;\n}\n/*\n * Find the smallest site position index greater than or equal to left\n * and right, i.e., slide each endpoint of an interval to the right\n * until they hit a site position. If both left and right map to the\n * the same position then we discard this edge. We also discard an\n * edge if left = 0 and right is less than the first site position.\n */\nstatic bool\nsimplifier_map_reduced_coordinates(simplifier_t *self, double *left, double *right)\n{\n double *X = self->position_lookup;\n tsk_size_t N = self->input_tables.sites.num_rows + 2;\n tsk_size_t left_index, right_index;\n bool skip = false;\n\n left_index = tsk_search_sorted(X, N, *left);\n right_index = tsk_search_sorted(X, N, *right);\n if (left_index == right_index || (left_index == 0 && right_index == 1)) {\n skip = true;\n } else {\n /* Remap back to zero if the left end maps to the first site. */\n if (left_index == 1) {\n left_index = 0;\n }\n *left = X[left_index];\n *right = X[right_index];\n }\n return skip;\n}\n\n/* Records the specified edge for the current parent by buffering it */\nstatic int\nsimplifier_record_edge(simplifier_t *self, double left, double right, tsk_id_t child)\n{\n int ret = 0;\n interval_list_t *tail, *x;\n bool skip;\n\n if (self->options & TSK_SIMPLIFY_REDUCE_TO_SITE_TOPOLOGY) {\n skip = simplifier_map_reduced_coordinates(self, &left, &right);\n /* NOTE: we exit early here when reduce_coordindates has told us to\n * skip this edge, as it is not visible in the reduced tree sequence */\n if (skip) {\n goto out;\n }\n }\n\n tail = self->child_edge_map_tail[child];\n if (tail == NULL) {\n tsk_bug_assert(self->num_buffered_children < self->input_tables.nodes.num_rows);\n self->buffered_children[self->num_buffered_children] = child;\n self->num_buffered_children++;\n x = simplifier_alloc_interval_list(self, left, right);\n if (x == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n self->child_edge_map_head[child] = x;\n self->child_edge_map_tail[child] = x;\n } else {\n if (tail->right == left) {\n tail->right = right;\n } else {\n x = simplifier_alloc_interval_list(self, left, right);\n if (x == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tail->next = x;\n self->child_edge_map_tail[child] = x;\n }\n }\nout:\n return ret;\n}\n\nstatic int\nsimplifier_init_sites(simplifier_t *self)\n{\n int ret = 0;\n tsk_id_t node;\n mutation_id_list_t *list_node;\n tsk_size_t j;\n\n self->mutation_node_map\n = tsk_calloc(self->input_tables.mutations.num_rows, sizeof(tsk_id_t));\n self->node_mutation_list_mem\n = tsk_malloc(self->input_tables.mutations.num_rows * sizeof(mutation_id_list_t));\n self->node_mutation_list_map_head\n = tsk_calloc(self->input_tables.nodes.num_rows, sizeof(mutation_id_list_t *));\n self->node_mutation_list_map_tail\n = tsk_calloc(self->input_tables.nodes.num_rows, sizeof(mutation_id_list_t *));\n if (self->mutation_node_map == NULL || self->node_mutation_list_mem == NULL\n || self->node_mutation_list_map_head == NULL\n || self->node_mutation_list_map_tail == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(self->mutation_node_map, 0xff,\n self->input_tables.mutations.num_rows * sizeof(tsk_id_t));\n\n for (j = 0; j < self->input_tables.mutations.num_rows; j++) {\n node = self->input_tables.mutations.node[j];\n list_node = self->node_mutation_list_mem + j;\n list_node->mutation = (tsk_id_t) j;\n list_node->next = NULL;\n if (self->node_mutation_list_map_head[node] == NULL) {\n self->node_mutation_list_map_head[node] = list_node;\n } else {\n self->node_mutation_list_map_tail[node]->next = list_node;\n }\n self->node_mutation_list_map_tail[node] = list_node;\n }\nout:\n return ret;\n}\n\nstatic void\nsimplifier_map_mutations(\n simplifier_t *self, tsk_id_t input_id, double left, double right, tsk_id_t output_id)\n{\n mutation_id_list_t *m_node;\n double position;\n tsk_id_t site;\n\n m_node = self->node_mutation_list_map_head[input_id];\n while (m_node != NULL) {\n site = self->input_tables.mutations.site[m_node->mutation];\n position = self->input_tables.sites.position[site];\n if (left <= position && position < right) {\n self->mutation_node_map[m_node->mutation] = output_id;\n }\n m_node = m_node->next;\n }\n}\n\nstatic int TSK_WARN_UNUSED\nsimplifier_add_ancestry(\n simplifier_t *self, tsk_id_t input_id, double left, double right, tsk_id_t output_id)\n{\n int ret = 0;\n tsk_segment_t *tail = self->ancestor_map_tail[input_id];\n tsk_segment_t *x;\n\n tsk_bug_assert(left < right);\n if (tail == NULL) {\n x = simplifier_alloc_segment(self, left, right, output_id);\n if (x == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n self->ancestor_map_head[input_id] = x;\n self->ancestor_map_tail[input_id] = x;\n } else {\n if (tail->right == left && tail->node == output_id) {\n tail->right = right;\n } else {\n x = simplifier_alloc_segment(self, left, right, output_id);\n if (x == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tail->next = x;\n self->ancestor_map_tail[input_id] = x;\n }\n }\n simplifier_map_mutations(self, input_id, left, right, output_id);\nout:\n return ret;\n}\n\n/* Sets up the internal working copies of the various tables, as needed\n * depending on the specified options. */\nstatic int\nsimplifier_init_tables(simplifier_t *self)\n{\n int ret;\n bool filter_nodes = !(self->options & TSK_SIMPLIFY_NO_FILTER_NODES);\n bool filter_populations = self->options & TSK_SIMPLIFY_FILTER_POPULATIONS;\n bool filter_individuals = self->options & TSK_SIMPLIFY_FILTER_INDIVIDUALS;\n bool filter_sites = self->options & TSK_SIMPLIFY_FILTER_SITES;\n tsk_bookmark_t rows_to_retain;\n\n /* NOTE: this is a bit inefficient here as we're taking copies of\n * the tables even in the no-filter case where the original tables\n * won't be touched (beyond references to external tables that may\n * need updating). Future versions may do something a bit more\n * complicated like temporarily stealing the pointers to the\n * underlying column memory in these tables, and then being careful\n * not to free the table at the end.\n */\n ret = tsk_table_collection_copy(self->tables, &self->input_tables, 0);\n if (ret != 0) {\n goto out;\n }\n memset(&rows_to_retain, 0, sizeof(rows_to_retain));\n rows_to_retain.provenances = self->tables->provenances.num_rows;\n if (!filter_nodes) {\n rows_to_retain.nodes = self->tables->nodes.num_rows;\n }\n if (!filter_populations) {\n rows_to_retain.populations = self->tables->populations.num_rows;\n }\n if (!filter_individuals) {\n rows_to_retain.individuals = self->tables->individuals.num_rows;\n }\n if (!filter_sites) {\n rows_to_retain.sites = self->tables->sites.num_rows;\n }\n\n ret = tsk_table_collection_truncate(self->tables, &rows_to_retain);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int\nsimplifier_init_nodes(simplifier_t *self, const tsk_id_t *samples)\n{\n int ret = 0;\n tsk_id_t node_id;\n tsk_size_t j;\n const tsk_size_t num_nodes = self->input_tables.nodes.num_rows;\n bool filter_nodes = !(self->options & TSK_SIMPLIFY_NO_FILTER_NODES);\n bool update_flags = !(self->options & TSK_SIMPLIFY_NO_UPDATE_SAMPLE_FLAGS);\n tsk_flags_t *node_flags = self->tables->nodes.flags;\n tsk_id_t *node_id_map = self->node_id_map;\n\n if (filter_nodes) {\n tsk_bug_assert(self->tables->nodes.num_rows == 0);\n /* The node table has been cleared. Add nodes for the samples. */\n for (j = 0; j < self->num_samples; j++) {\n node_id = simplifier_record_node(self, samples[j]);\n if (node_id < 0) {\n ret = (int) node_id;\n goto out;\n }\n }\n } else {\n tsk_bug_assert(self->tables->nodes.num_rows == num_nodes);\n if (update_flags) {\n for (j = 0; j < num_nodes; j++) {\n /* Reset the sample flags */\n node_flags[j] &= (tsk_flags_t) ~TSK_NODE_IS_SAMPLE;\n if (self->is_sample[j]) {\n node_flags[j] |= TSK_NODE_IS_SAMPLE;\n }\n }\n }\n\n for (j = 0; j < num_nodes; j++) {\n node_id_map[j] = (tsk_id_t) j;\n }\n }\n /* Add the initial ancestry */\n for (j = 0; j < self->num_samples; j++) {\n node_id = samples[j];\n ret = simplifier_add_ancestry(self, node_id, 0,\n self->input_tables.sequence_length, self->node_id_map[node_id]);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int\nsimplifier_init(simplifier_t *self, const tsk_id_t *samples, tsk_size_t num_samples,\n tsk_table_collection_t *tables, tsk_flags_t options)\n{\n int ret = 0;\n tsk_size_t j;\n tsk_id_t ret_id;\n tsk_size_t num_nodes;\n\n tsk_memset(self, 0, sizeof(simplifier_t));\n self->num_samples = num_samples;\n self->options = options;\n self->tables = tables;\n\n /* TODO we can add a flag to skip these checks for when we know they are\n * unnecessary */\n /* TODO Current unit tests require TSK_CHECK_SITE_DUPLICATES but it's\n * debateable whether we need it. If we remove, we definitely need explicit\n * tests to ensure we're doing sensible things with duplicate sites.\n * (Particularly, re TSK_SIMPLIFY_REDUCE_TO_SITE_TOPOLOGY.) */\n ret_id = tsk_table_collection_check_integrity(tables,\n TSK_CHECK_EDGE_ORDERING | TSK_CHECK_SITE_ORDERING | TSK_CHECK_SITE_DUPLICATES);\n if (ret_id != 0) {\n ret = (int) ret_id;\n goto out;\n }\n\n /* Allocate the heaps used for small objects-> Assuming 8K is a good chunk size\n */\n ret = tsk_blkalloc_init(&self->segment_heap, 8192);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_blkalloc_init(&self->interval_list_heap, 8192);\n if (ret != 0) {\n goto out;\n }\n ret = segment_overlapper_alloc(&self->segment_overlapper);\n if (ret != 0) {\n goto out;\n }\n num_nodes = tables->nodes.num_rows;\n /* Make the maps and set the intial state */\n self->ancestor_map_head = tsk_calloc(num_nodes, sizeof(tsk_segment_t *));\n self->ancestor_map_tail = tsk_calloc(num_nodes, sizeof(tsk_segment_t *));\n self->child_edge_map_head = tsk_calloc(num_nodes, sizeof(interval_list_t *));\n self->child_edge_map_tail = tsk_calloc(num_nodes, sizeof(interval_list_t *));\n self->node_id_map = tsk_malloc(num_nodes * sizeof(tsk_id_t));\n self->buffered_children = tsk_malloc(num_nodes * sizeof(tsk_id_t));\n self->is_sample = tsk_calloc(num_nodes, sizeof(bool));\n self->max_segment_queue_size = 64;\n self->segment_queue\n = tsk_malloc(self->max_segment_queue_size * sizeof(tsk_segment_t));\n if (self->ancestor_map_head == NULL || self->ancestor_map_tail == NULL\n || self->child_edge_map_head == NULL || self->child_edge_map_tail == NULL\n || self->node_id_map == NULL || self->is_sample == NULL\n || self->segment_queue == NULL || self->buffered_children == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n /* Go through the samples to check for errors before we clear the tables. */\n for (j = 0; j < self->num_samples; j++) {\n if (samples[j] < 0 || samples[j] >= (tsk_id_t) num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n if (self->is_sample[samples[j]]) {\n ret = tsk_trace_error(TSK_ERR_DUPLICATE_SAMPLE);\n goto out;\n }\n self->is_sample[samples[j]] = true;\n }\n tsk_memset(self->node_id_map, 0xff, num_nodes * sizeof(tsk_id_t));\n\n ret = simplifier_init_tables(self);\n if (ret != 0) {\n goto out;\n }\n ret = simplifier_init_sites(self);\n if (ret != 0) {\n goto out;\n }\n ret = simplifier_init_nodes(self, samples);\n if (ret != 0) {\n goto out;\n }\n if (self->options & TSK_SIMPLIFY_REDUCE_TO_SITE_TOPOLOGY) {\n ret = simplifier_init_position_lookup(self);\n if (ret != 0) {\n goto out;\n }\n }\n\n self->edge_sort_offset = TSK_NULL;\nout:\n return ret;\n}\n\nstatic int\nsimplifier_free(simplifier_t *self)\n{\n tsk_table_collection_free(&self->input_tables);\n tsk_blkalloc_free(&self->segment_heap);\n tsk_blkalloc_free(&self->interval_list_heap);\n segment_overlapper_free(&self->segment_overlapper);\n tsk_safe_free(self->ancestor_map_head);\n tsk_safe_free(self->ancestor_map_tail);\n tsk_safe_free(self->child_edge_map_head);\n tsk_safe_free(self->child_edge_map_tail);\n tsk_safe_free(self->node_id_map);\n tsk_safe_free(self->segment_queue);\n tsk_safe_free(self->is_sample);\n tsk_safe_free(self->mutation_node_map);\n tsk_safe_free(self->node_mutation_list_mem);\n tsk_safe_free(self->node_mutation_list_map_head);\n tsk_safe_free(self->node_mutation_list_map_tail);\n tsk_safe_free(self->buffered_children);\n tsk_safe_free(self->position_lookup);\n return 0;\n}\n\nstatic int TSK_WARN_UNUSED\nsimplifier_enqueue_segment(simplifier_t *self, double left, double right, tsk_id_t node)\n{\n int ret = 0;\n tsk_segment_t *seg;\n void *p;\n\n tsk_bug_assert(left < right);\n /* Make sure we always have room for one more segment in the queue so we\n * can put a tail sentinel on it */\n if (self->segment_queue_size == self->max_segment_queue_size - 1) {\n self->max_segment_queue_size *= 2;\n p = tsk_realloc(self->segment_queue,\n self->max_segment_queue_size * sizeof(*self->segment_queue));\n if (p == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n self->segment_queue = p;\n }\n seg = self->segment_queue + self->segment_queue_size;\n seg->left = left;\n seg->right = right;\n seg->node = node;\n self->segment_queue_size++;\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\nsimplifier_merge_ancestors(simplifier_t *self, tsk_id_t input_id)\n{\n int ret = 0;\n tsk_segment_t **X, *x;\n tsk_size_t j, num_overlapping, num_flushed_edges;\n double left, right, prev_right;\n tsk_id_t ancestry_node;\n tsk_id_t output_id = self->node_id_map[input_id];\n bool is_sample = self->is_sample[input_id];\n bool filter_nodes = !(self->options & TSK_SIMPLIFY_NO_FILTER_NODES);\n bool keep_unary = self->options & TSK_SIMPLIFY_KEEP_UNARY;\n\n if ((self->options & TSK_SIMPLIFY_KEEP_UNARY_IN_INDIVIDUALS)\n && (self->input_tables.nodes.individual[input_id] != TSK_NULL)) {\n keep_unary = true;\n }\n\n if (is_sample) {\n /* Free up the existing ancestry mapping. */\n x = self->ancestor_map_tail[input_id];\n tsk_bug_assert(x->left == 0 && x->right == self->tables->sequence_length);\n self->ancestor_map_head[input_id] = NULL;\n self->ancestor_map_tail[input_id] = NULL;\n }\n\n ret = segment_overlapper_start(\n &self->segment_overlapper, self->segment_queue, self->segment_queue_size);\n if (ret != 0) {\n goto out;\n }\n prev_right = 0;\n while ((ret = segment_overlapper_next(\n &self->segment_overlapper, &left, &right, &X, &num_overlapping))\n == 1) {\n tsk_bug_assert(left < right);\n tsk_bug_assert(num_overlapping > 0);\n if (num_overlapping == 1) {\n ancestry_node = X[0]->node;\n if (is_sample) {\n ret = simplifier_record_edge(self, left, right, ancestry_node);\n if (ret != 0) {\n goto out;\n }\n ancestry_node = output_id;\n } else if (keep_unary) {\n if (output_id == TSK_NULL) {\n output_id = simplifier_record_node(self, input_id);\n }\n ret = simplifier_record_edge(self, left, right, ancestry_node);\n if (ret != 0) {\n goto out;\n }\n }\n } else {\n if (output_id == TSK_NULL) {\n output_id = simplifier_record_node(self, input_id);\n if (output_id < 0) {\n ret = (int) output_id;\n goto out;\n }\n }\n ancestry_node = output_id;\n for (j = 0; j < num_overlapping; j++) {\n ret = simplifier_record_edge(self, left, right, X[j]->node);\n if (ret != 0) {\n goto out;\n }\n }\n }\n if (is_sample && left != prev_right) {\n /* Fill in any gaps in ancestry for the sample */\n ret = simplifier_add_ancestry(self, input_id, prev_right, left, output_id);\n if (ret != 0) {\n goto out;\n }\n }\n if (keep_unary) {\n ancestry_node = output_id;\n }\n ret = simplifier_add_ancestry(self, input_id, left, right, ancestry_node);\n if (ret != 0) {\n goto out;\n }\n prev_right = right;\n }\n /* Check for errors occuring in the loop condition */\n if (ret != 0) {\n goto out;\n }\n if (is_sample && prev_right != self->tables->sequence_length) {\n /* If a trailing gap exists in the sample ancestry, fill it in. */\n ret = simplifier_add_ancestry(\n self, input_id, prev_right, self->tables->sequence_length, output_id);\n if (ret != 0) {\n goto out;\n }\n }\n if (output_id != TSK_NULL) {\n ret = simplifier_flush_edges(self, output_id, &num_flushed_edges);\n if (ret != 0) {\n goto out;\n }\n if (filter_nodes && (num_flushed_edges == 0) && !is_sample) {\n ret = simplifier_rewind_node(self, input_id, output_id);\n }\n }\nout:\n return ret;\n}\n\n/* Extract the ancestry for the specified input node over the specified\n * interval and queue it up for merging.\n */\nstatic int TSK_WARN_UNUSED\nsimplifier_extract_ancestry(\n simplifier_t *self, double left, double right, tsk_id_t input_id)\n{\n int ret = 0;\n tsk_segment_t *x = self->ancestor_map_head[input_id];\n tsk_segment_t y; /* y is the segment that has been removed */\n tsk_segment_t *x_head, *x_prev, *seg_left, *seg_right;\n\n x_head = NULL;\n x_prev = NULL;\n while (x != NULL) {\n if (x->right > left && right > x->left) {\n y.left = TSK_MAX(x->left, left);\n y.right = TSK_MIN(x->right, right);\n y.node = x->node;\n ret = simplifier_enqueue_segment(self, y.left, y.right, y.node);\n if (ret != 0) {\n goto out;\n }\n seg_left = NULL;\n seg_right = NULL;\n if (x->left != y.left) {\n seg_left = simplifier_alloc_segment(self, x->left, y.left, x->node);\n if (seg_left == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n if (x_prev == NULL) {\n x_head = seg_left;\n } else {\n x_prev->next = seg_left;\n }\n x_prev = seg_left;\n }\n if (x->right != y.right) {\n x->left = y.right;\n seg_right = x;\n } else {\n seg_right = x->next;\n // TODO free x\n }\n if (x_prev == NULL) {\n x_head = seg_right;\n } else {\n x_prev->next = seg_right;\n }\n x = seg_right;\n } else {\n if (x_prev == NULL) {\n x_head = x;\n }\n x_prev = x;\n x = x->next;\n }\n }\n\n self->ancestor_map_head[input_id] = x_head;\n self->ancestor_map_tail[input_id] = x_prev;\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\nsimplifier_process_parent_edges(\n simplifier_t *self, tsk_id_t parent, tsk_size_t start, tsk_size_t end)\n{\n int ret = 0;\n tsk_size_t j;\n const tsk_edge_table_t *input_edges = &self->input_tables.edges;\n tsk_id_t child;\n double left, right;\n\n /* Go through the edges and queue up ancestry segments for processing. */\n self->segment_queue_size = 0;\n for (j = start; j < end; j++) {\n tsk_bug_assert(parent == input_edges->parent[j]);\n child = input_edges->child[j];\n left = input_edges->left[j];\n right = input_edges->right[j];\n ret = simplifier_extract_ancestry(self, left, right, child);\n if (ret != 0) {\n goto out;\n }\n }\n /* We can now merge the ancestral segments for the parent */\n ret = simplifier_merge_ancestors(self, parent);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\nsimplifier_finalise_site_references(\n simplifier_t *self, const bool *site_referenced, tsk_id_t *site_id_map)\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_site_t site;\n const tsk_size_t num_sites = self->input_tables.sites.num_rows;\n\n if (self->options & TSK_SIMPLIFY_FILTER_SITES) {\n for (j = 0; j < num_sites; j++) {\n tsk_site_table_get_row_unsafe(\n &self->input_tables.sites, (tsk_id_t) j, &site);\n site_id_map[j] = TSK_NULL;\n if (site_referenced[j]) {\n ret_id = tsk_site_table_add_row(&self->tables->sites, site.position,\n site.ancestral_state, site.ancestral_state_length, site.metadata,\n site.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n site_id_map[j] = ret_id;\n }\n }\n } else {\n tsk_bug_assert(self->tables->sites.num_rows == num_sites);\n for (j = 0; j < num_sites; j++) {\n site_id_map[j] = (tsk_id_t) j;\n }\n }\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\nsimplifier_finalise_population_references(simplifier_t *self)\n{\n int ret = 0;\n tsk_size_t j;\n tsk_id_t pop_id, ret_id;\n tsk_population_t pop;\n tsk_id_t *node_population = self->tables->nodes.population;\n const tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const tsk_size_t num_populations = self->input_tables.populations.num_rows;\n bool *population_referenced\n = tsk_calloc(num_populations, sizeof(*population_referenced));\n tsk_id_t *population_id_map\n = tsk_malloc(num_populations * sizeof(*population_id_map));\n\n tsk_bug_assert(self->options & TSK_SIMPLIFY_FILTER_POPULATIONS);\n\n if (population_referenced == NULL || population_id_map == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n for (j = 0; j < num_nodes; j++) {\n pop_id = node_population[j];\n if (pop_id != TSK_NULL) {\n population_referenced[pop_id] = true;\n }\n }\n\n for (j = 0; j < num_populations; j++) {\n tsk_population_table_get_row_unsafe(\n &self->input_tables.populations, (tsk_id_t) j, &pop);\n population_id_map[j] = TSK_NULL;\n if (population_referenced[j]) {\n ret_id = tsk_population_table_add_row(\n &self->tables->populations, pop.metadata, pop.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n population_id_map[j] = ret_id;\n }\n }\n\n /* Remap the IDs in the node table */\n for (j = 0; j < num_nodes; j++) {\n pop_id = node_population[j];\n if (pop_id != TSK_NULL) {\n node_population[j] = population_id_map[pop_id];\n }\n }\nout:\n tsk_safe_free(population_id_map);\n tsk_safe_free(population_referenced);\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\nsimplifier_finalise_individual_references(simplifier_t *self)\n{\n int ret = 0;\n tsk_size_t j;\n tsk_id_t pop_id, ret_id;\n tsk_individual_t ind;\n tsk_id_t *node_individual = self->tables->nodes.individual;\n tsk_id_t *parents;\n const tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const tsk_size_t num_individuals = self->input_tables.individuals.num_rows;\n bool *individual_referenced\n = tsk_calloc(num_individuals, sizeof(*individual_referenced));\n tsk_id_t *individual_id_map\n = tsk_malloc(num_individuals * sizeof(*individual_id_map));\n\n tsk_bug_assert(self->options & TSK_SIMPLIFY_FILTER_INDIVIDUALS);\n\n if (individual_referenced == NULL || individual_id_map == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n for (j = 0; j < num_nodes; j++) {\n pop_id = node_individual[j];\n if (pop_id != TSK_NULL) {\n individual_referenced[pop_id] = true;\n }\n }\n\n for (j = 0; j < num_individuals; j++) {\n tsk_individual_table_get_row_unsafe(\n &self->input_tables.individuals, (tsk_id_t) j, &ind);\n individual_id_map[j] = TSK_NULL;\n if (individual_referenced[j]) {\n /* Can't remap the parents inline here because we have no\n * guarantees about sortedness */\n ret_id = tsk_individual_table_add_row(&self->tables->individuals, ind.flags,\n ind.location, ind.location_length, ind.parents, ind.parents_length,\n ind.metadata, ind.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n individual_id_map[j] = ret_id;\n }\n }\n\n /* Remap the IDs in the node table */\n for (j = 0; j < num_nodes; j++) {\n pop_id = node_individual[j];\n if (pop_id != TSK_NULL) {\n node_individual[j] = individual_id_map[pop_id];\n }\n }\n\n /* Remap parent IDs. *\n * NOTE! must take the pointer reference here as it can change from\n * the start of the function */\n parents = self->tables->individuals.parents;\n for (j = 0; j < self->tables->individuals.parents_length; j++) {\n if (parents[j] != TSK_NULL) {\n parents[j] = individual_id_map[parents[j]];\n }\n }\n\nout:\n tsk_safe_free(individual_id_map);\n tsk_safe_free(individual_referenced);\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\nsimplifier_output_sites(simplifier_t *self)\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_size_t j;\n tsk_mutation_t mutation;\n const tsk_size_t num_sites = self->input_tables.sites.num_rows;\n const tsk_size_t num_mutations = self->input_tables.mutations.num_rows;\n bool *site_referenced = tsk_calloc(num_sites, sizeof(*site_referenced));\n tsk_id_t *site_id_map = tsk_malloc(num_sites * sizeof(*site_id_map));\n tsk_id_t *mutation_id_map = tsk_malloc(num_mutations * sizeof(*mutation_id_map));\n const tsk_id_t *mutation_node_map = self->mutation_node_map;\n const tsk_id_t *mutation_site = self->input_tables.mutations.site;\n\n if (site_referenced == NULL || site_id_map == NULL || mutation_id_map == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n for (j = 0; j < num_mutations; j++) {\n if (mutation_node_map[j] != TSK_NULL) {\n site_referenced[mutation_site[j]] = true;\n }\n }\n ret = simplifier_finalise_site_references(self, site_referenced, site_id_map);\n if (ret != 0) {\n goto out;\n }\n\n for (j = 0; j < num_mutations; j++) {\n mutation_id_map[j] = TSK_NULL;\n if (mutation_node_map[j] != TSK_NULL) {\n tsk_mutation_table_get_row_unsafe(\n &self->input_tables.mutations, (tsk_id_t) j, &mutation);\n mutation.node = mutation_node_map[j];\n mutation.site = site_id_map[mutation.site];\n if (mutation.parent != TSK_NULL) {\n mutation.parent = mutation_id_map[mutation.parent];\n }\n ret_id = tsk_mutation_table_add_row(&self->tables->mutations, mutation.site,\n mutation.node, mutation.parent, mutation.time, mutation.derived_state,\n mutation.derived_state_length, mutation.metadata,\n mutation.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n mutation_id_map[j] = ret_id;\n }\n }\nout:\n tsk_safe_free(site_referenced);\n tsk_safe_free(site_id_map);\n tsk_safe_free(mutation_id_map);\n return ret;\n}\n\n/* Flush the remaining non-edge and node data in the model to the\n * output tables. */\nstatic int TSK_WARN_UNUSED\nsimplifier_flush_output(simplifier_t *self)\n{\n int ret = 0;\n\n /* TODO Migrations fit reasonably neatly into the pattern that we have here. We\n * can consider references to populations from migration objects in the same way\n * as from nodes, so that we only remove a population if its referenced by\n * neither. Mapping the population IDs in migrations is then easy. In principle\n * nodes are similar, but the semantics are slightly different because we've\n * already allocated all the nodes by their references from edges. We then\n * need to decide whether we remove migrations that reference unmapped nodes\n * or whether to add these nodes back in (probably the former is the correct\n * approach).*/\n if (self->input_tables.migrations.num_rows != 0) {\n ret = tsk_trace_error(TSK_ERR_SIMPLIFY_MIGRATIONS_NOT_SUPPORTED);\n goto out;\n }\n\n ret = simplifier_output_sites(self);\n if (ret != 0) {\n goto out;\n }\n\n if (self->options & TSK_SIMPLIFY_FILTER_POPULATIONS) {\n ret = simplifier_finalise_population_references(self);\n if (ret != 0) {\n goto out;\n }\n }\n if (self->options & TSK_SIMPLIFY_FILTER_INDIVIDUALS) {\n ret = simplifier_finalise_individual_references(self);\n if (ret != 0) {\n goto out;\n }\n }\n\nout:\n return ret;\n}\n\nstatic void\nsimplifier_set_edge_sort_offset(simplifier_t *self, double youngest_root_time)\n{\n const tsk_edge_table_t edges = self->tables->edges;\n const double *node_time = self->tables->nodes.time;\n int64_t offset;\n\n for (offset = 0; offset < (int64_t) edges.num_rows; offset++) {\n if (node_time[edges.parent[offset]] >= youngest_root_time) {\n break;\n }\n }\n self->edge_sort_offset = offset;\n}\n\nstatic int TSK_WARN_UNUSED\nsimplifier_sort_edges(simplifier_t *self)\n{\n /* designated initialisers are guaranteed to set any missing fields to\n * zero, so we don't need to set the rest of them. */\n tsk_bookmark_t bookmark = {\n .edges = (tsk_size_t) self->edge_sort_offset,\n .sites = self->tables->sites.num_rows,\n .mutations = self->tables->mutations.num_rows,\n };\n tsk_bug_assert(self->edge_sort_offset >= 0);\n return tsk_table_collection_sort(self->tables, &bookmark, 0);\n}\n\nstatic int TSK_WARN_UNUSED\nsimplifier_insert_input_roots(simplifier_t *self)\n{\n int ret = 0;\n tsk_id_t input_id, output_id;\n tsk_segment_t *x;\n tsk_size_t num_flushed_edges;\n double youngest_root_time = DBL_MAX;\n const double *node_time = self->tables->nodes.time;\n\n for (input_id = 0; input_id < (tsk_id_t) self->input_tables.nodes.num_rows;\n input_id++) {\n x = self->ancestor_map_head[input_id];\n if (x != NULL) {\n output_id = self->node_id_map[input_id];\n if (output_id == TSK_NULL) {\n output_id = simplifier_record_node(self, input_id);\n if (output_id < 0) {\n ret = (int) output_id;\n goto out;\n }\n }\n youngest_root_time = TSK_MIN(youngest_root_time, node_time[output_id]);\n while (x != NULL) {\n if (x->node != output_id) {\n ret = simplifier_record_edge(self, x->left, x->right, x->node);\n if (ret != 0) {\n goto out;\n }\n simplifier_map_mutations(\n self, input_id, x->left, x->right, output_id);\n }\n x = x->next;\n }\n ret = simplifier_flush_edges(self, output_id, &num_flushed_edges);\n if (ret != 0) {\n goto out;\n }\n }\n }\n if (youngest_root_time != DBL_MAX) {\n simplifier_set_edge_sort_offset(self, youngest_root_time);\n }\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\nsimplifier_run(simplifier_t *self, tsk_id_t *node_map)\n{\n int ret = 0;\n tsk_size_t j, start;\n tsk_id_t parent, current_parent;\n const tsk_edge_table_t *input_edges = &self->input_tables.edges;\n tsk_size_t num_edges = input_edges->num_rows;\n\n if (num_edges > 0) {\n start = 0;\n current_parent = input_edges->parent[0];\n for (j = 0; j < num_edges; j++) {\n parent = input_edges->parent[j];\n if (parent != current_parent) {\n ret = simplifier_process_parent_edges(self, current_parent, start, j);\n if (ret != 0) {\n goto out;\n }\n current_parent = parent;\n start = j;\n }\n }\n ret = simplifier_process_parent_edges(self, current_parent, start, num_edges);\n if (ret != 0) {\n goto out;\n }\n }\n if (self->options & TSK_SIMPLIFY_KEEP_INPUT_ROOTS) {\n ret = simplifier_insert_input_roots(self);\n if (ret != 0) {\n goto out;\n }\n }\n ret = simplifier_flush_output(self);\n if (ret != 0) {\n goto out;\n }\n if (node_map != NULL) {\n /* Finally, output the new IDs for the nodes, if required. */\n tsk_memcpy(node_map, self->node_id_map,\n self->input_tables.nodes.num_rows * sizeof(tsk_id_t));\n }\n if (self->edge_sort_offset != TSK_NULL) {\n tsk_bug_assert(self->options & TSK_SIMPLIFY_KEEP_INPUT_ROOTS);\n ret = simplifier_sort_edges(self);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\n/*************************\n * table_collection\n *************************/\n\ntypedef struct {\n tsk_id_t index;\n /* These are the sort keys in order */\n double first;\n double second;\n tsk_id_t third;\n tsk_id_t fourth;\n} index_sort_t;\n\nstatic int\ncmp_index_sort(const void *a, const void *b)\n{\n const index_sort_t *ca = (const index_sort_t *) a;\n const index_sort_t *cb = (const index_sort_t *) b;\n int ret = (ca->first > cb->first) - (ca->first < cb->first);\n if (ret == 0) {\n ret = (ca->second > cb->second) - (ca->second < cb->second);\n if (ret == 0) {\n ret = (ca->third > cb->third) - (ca->third < cb->third);\n if (ret == 0) {\n ret = (ca->fourth > cb->fourth) - (ca->fourth < cb->fourth);\n }\n }\n }\n return ret;\n}\n\nstatic int\ntsk_table_collection_check_offsets(const tsk_table_collection_t *self)\n{\n int ret = 0;\n\n ret = check_offsets(self->nodes.num_rows, self->nodes.metadata_offset,\n self->nodes.metadata_length, true);\n if (ret != 0) {\n goto out;\n }\n ret = check_offsets(self->sites.num_rows, self->sites.ancestral_state_offset,\n self->sites.ancestral_state_length, true);\n if (ret != 0) {\n goto out;\n }\n ret = check_offsets(self->sites.num_rows, self->sites.metadata_offset,\n self->sites.metadata_length, true);\n if (ret != 0) {\n goto out;\n }\n ret = check_offsets(self->mutations.num_rows, self->mutations.derived_state_offset,\n self->mutations.derived_state_length, true);\n if (ret != 0) {\n goto out;\n }\n ret = check_offsets(self->mutations.num_rows, self->mutations.metadata_offset,\n self->mutations.metadata_length, true);\n if (ret != 0) {\n goto out;\n }\n ret = check_offsets(self->individuals.num_rows, self->individuals.metadata_offset,\n self->individuals.metadata_length, true);\n if (ret != 0) {\n goto out;\n }\n ret = check_offsets(self->provenances.num_rows, self->provenances.timestamp_offset,\n self->provenances.timestamp_length, true);\n if (ret != 0) {\n goto out;\n }\n ret = check_offsets(self->provenances.num_rows, self->provenances.record_offset,\n self->provenances.record_length, true);\n if (ret != 0) {\n goto out;\n }\n ret = 0;\nout:\n return ret;\n}\n\nstatic int\ntsk_table_collection_check_node_integrity(\n const tsk_table_collection_t *self, tsk_flags_t options)\n{\n int ret = 0;\n tsk_size_t j;\n double node_time;\n tsk_id_t population, individual;\n tsk_id_t num_populations = (tsk_id_t) self->populations.num_rows;\n tsk_id_t num_individuals = (tsk_id_t) self->individuals.num_rows;\n const bool check_population_refs = !(options & TSK_NO_CHECK_POPULATION_REFS);\n\n for (j = 0; j < self->nodes.num_rows; j++) {\n node_time = self->nodes.time[j];\n if (!tsk_isfinite(node_time)) {\n ret = tsk_trace_error(TSK_ERR_TIME_NONFINITE);\n goto out;\n }\n if (check_population_refs) {\n population = self->nodes.population[j];\n if (population < TSK_NULL || population >= num_populations) {\n ret = tsk_trace_error(TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n goto out;\n }\n }\n individual = self->nodes.individual[j];\n if (individual < TSK_NULL || individual >= num_individuals) {\n ret = tsk_trace_error(TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_table_collection_check_edge_integrity(\n const tsk_table_collection_t *self, tsk_flags_t options)\n{\n int ret = 0;\n tsk_size_t j;\n tsk_id_t parent, last_parent, child, last_child;\n double left, last_left, right;\n const double *time = self->nodes.time;\n const double L = self->sequence_length;\n const tsk_edge_table_t edges = self->edges;\n const tsk_id_t num_nodes = (tsk_id_t) self->nodes.num_rows;\n const bool check_ordering = !!(options & TSK_CHECK_EDGE_ORDERING);\n bool *parent_seen = NULL;\n\n if (check_ordering) {\n parent_seen = tsk_calloc((tsk_size_t) num_nodes, sizeof(*parent_seen));\n if (parent_seen == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n }\n\n /* Just keeping compiler happy; these values don't matter. */\n last_left = 0;\n last_parent = 0;\n last_child = 0;\n for (j = 0; j < edges.num_rows; j++) {\n parent = edges.parent[j];\n child = edges.child[j];\n left = edges.left[j];\n right = edges.right[j];\n /* Node ID integrity */\n if (parent == TSK_NULL) {\n ret = tsk_trace_error(TSK_ERR_NULL_PARENT);\n goto out;\n }\n if (parent < 0 || parent >= num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n if (child == TSK_NULL) {\n ret = tsk_trace_error(TSK_ERR_NULL_CHILD);\n goto out;\n }\n if (child < 0 || child >= num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n /* Spatial requirements for edges */\n if (!(tsk_isfinite(left) && tsk_isfinite(right))) {\n ret = tsk_trace_error(TSK_ERR_GENOME_COORDS_NONFINITE);\n goto out;\n }\n if (left < 0) {\n ret = tsk_trace_error(TSK_ERR_LEFT_LESS_ZERO);\n goto out;\n }\n if (right > L) {\n ret = tsk_trace_error(TSK_ERR_RIGHT_GREATER_SEQ_LENGTH);\n goto out;\n }\n if (left >= right) {\n ret = tsk_trace_error(TSK_ERR_BAD_EDGE_INTERVAL);\n goto out;\n }\n /* time[child] must be < time[parent] */\n if (time[child] >= time[parent]) {\n ret = tsk_trace_error(TSK_ERR_BAD_NODE_TIME_ORDERING);\n goto out;\n }\n\n if (check_ordering) {\n if (parent_seen[parent]) {\n ret = tsk_trace_error(TSK_ERR_EDGES_NONCONTIGUOUS_PARENTS);\n goto out;\n }\n if (j > 0) {\n /* Input data must sorted by (time[parent], parent, child, left). */\n if (time[parent] < time[last_parent]) {\n ret = tsk_trace_error(TSK_ERR_EDGES_NOT_SORTED_PARENT_TIME);\n goto out;\n }\n if (time[parent] == time[last_parent]) {\n if (parent == last_parent) {\n if (child < last_child) {\n ret = tsk_trace_error(TSK_ERR_EDGES_NOT_SORTED_CHILD);\n goto out;\n }\n if (child == last_child) {\n if (left == last_left) {\n ret = tsk_trace_error(TSK_ERR_DUPLICATE_EDGES);\n goto out;\n } else if (left < last_left) {\n ret = tsk_trace_error(TSK_ERR_EDGES_NOT_SORTED_LEFT);\n goto out;\n }\n }\n } else {\n parent_seen[last_parent] = true;\n }\n }\n }\n last_parent = parent;\n last_child = child;\n last_left = left;\n }\n }\nout:\n tsk_safe_free(parent_seen);\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_table_collection_check_site_integrity(\n const tsk_table_collection_t *self, tsk_flags_t options)\n{\n int ret = 0;\n tsk_size_t j;\n double position;\n const double L = self->sequence_length;\n const tsk_site_table_t sites = self->sites;\n const bool check_site_ordering = !!(options & TSK_CHECK_SITE_ORDERING);\n const bool check_site_duplicates = !!(options & TSK_CHECK_SITE_DUPLICATES);\n\n for (j = 0; j < sites.num_rows; j++) {\n position = sites.position[j];\n /* Spatial requirements */\n if (!tsk_isfinite(position)) {\n ret = tsk_trace_error(TSK_ERR_BAD_SITE_POSITION);\n goto out;\n }\n if (position < 0 || position >= L) {\n ret = tsk_trace_error(TSK_ERR_BAD_SITE_POSITION);\n goto out;\n }\n if (j > 0) {\n if (check_site_duplicates && sites.position[j - 1] == position) {\n ret = tsk_trace_error(TSK_ERR_DUPLICATE_SITE_POSITION);\n goto out;\n }\n if (check_site_ordering && sites.position[j - 1] > position) {\n ret = tsk_trace_error(TSK_ERR_UNSORTED_SITES);\n goto out;\n }\n }\n }\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_table_collection_check_mutation_integrity(\n const tsk_table_collection_t *self, tsk_flags_t options)\n{\n int ret = 0;\n tsk_size_t j;\n tsk_id_t parent_mut;\n double mutation_time;\n double last_known_time = INFINITY;\n const tsk_mutation_table_t mutations = self->mutations;\n const tsk_id_t num_nodes = (tsk_id_t) self->nodes.num_rows;\n const tsk_id_t num_sites = (tsk_id_t) self->sites.num_rows;\n const tsk_id_t num_mutations = (tsk_id_t) self->mutations.num_rows;\n const double *node_time = self->nodes.time;\n const bool check_mutation_ordering = !!(options & TSK_CHECK_MUTATION_ORDERING);\n bool unknown_time;\n int num_known_times = 0;\n int num_unknown_times = 0;\n\n for (j = 0; j < mutations.num_rows; j++) {\n /* Basic reference integrity */\n if (mutations.site[j] < 0 || mutations.site[j] >= num_sites) {\n ret = tsk_trace_error(TSK_ERR_SITE_OUT_OF_BOUNDS);\n goto out;\n }\n if (mutations.node[j] < 0 || mutations.node[j] >= num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n /* Integrity check for mutation parent */\n parent_mut = mutations.parent[j];\n if (parent_mut < TSK_NULL || parent_mut >= num_mutations) {\n ret = tsk_trace_error(TSK_ERR_MUTATION_OUT_OF_BOUNDS);\n goto out;\n }\n if (parent_mut == (tsk_id_t) j) {\n ret = tsk_trace_error(TSK_ERR_MUTATION_PARENT_EQUAL);\n goto out;\n }\n /* Check that time is finite and not more recent than node time */\n mutation_time = mutations.time[j];\n unknown_time = tsk_is_unknown_time(mutation_time);\n if (!unknown_time) {\n if (!tsk_isfinite(mutation_time)) {\n ret = tsk_trace_error(TSK_ERR_TIME_NONFINITE);\n goto out;\n }\n if (mutation_time < node_time[mutations.node[j]]) {\n ret = tsk_trace_error(TSK_ERR_MUTATION_TIME_YOUNGER_THAN_NODE);\n goto out;\n }\n }\n\n /* reset checks when reaching a new site */\n if (j > 0 && mutations.site[j - 1] != mutations.site[j]) {\n last_known_time = INFINITY;\n num_known_times = 0;\n num_unknown_times = 0;\n }\n\n /* Check known/unknown times are not both present on a site */\n if (unknown_time) {\n num_unknown_times++;\n } else {\n num_known_times++;\n }\n if ((num_unknown_times > 0) && (num_known_times > 0)) {\n ret = tsk_trace_error(TSK_ERR_MUTATION_TIME_HAS_BOTH_KNOWN_AND_UNKNOWN);\n goto out;\n }\n\n /* check parent site agrees */\n if (parent_mut != TSK_NULL) {\n if (mutations.site[parent_mut] != mutations.site[j]) {\n ret = tsk_trace_error(TSK_ERR_MUTATION_PARENT_DIFFERENT_SITE);\n goto out;\n }\n /* If this mutation time is known, then the parent time\n * must also be, or else the\n * TSK_ERR_MUTATION_TIME_HAS_BOTH_KNOWN_AND_UNKNOWN check\n * above will fail. */\n if (!unknown_time && mutation_time > mutations.time[parent_mut]) {\n ret = tsk_trace_error(TSK_ERR_MUTATION_TIME_OLDER_THAN_PARENT_MUTATION);\n goto out;\n }\n }\n\n if (check_mutation_ordering) {\n /* Check site ordering */\n if (j > 0 && mutations.site[j - 1] > mutations.site[j]) {\n ret = tsk_trace_error(TSK_ERR_UNSORTED_MUTATIONS);\n goto out;\n }\n\n /* Check if parents are listed before their children */\n if (parent_mut != TSK_NULL && parent_mut > (tsk_id_t) j) {\n ret = tsk_trace_error(TSK_ERR_MUTATION_PARENT_AFTER_CHILD);\n goto out;\n }\n\n /* Check time ordering. We do this after the other checks above,\n * so that more specific errors trigger first */\n if (!unknown_time) {\n if (mutation_time > last_known_time) {\n ret = tsk_trace_error(TSK_ERR_UNSORTED_MUTATIONS);\n goto out;\n }\n last_known_time = mutation_time;\n }\n }\n }\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_table_collection_check_migration_integrity(\n const tsk_table_collection_t *self, tsk_flags_t options)\n{\n int ret = 0;\n tsk_size_t j;\n double left, right, time;\n const double L = self->sequence_length;\n const tsk_migration_table_t migrations = self->migrations;\n const tsk_id_t num_nodes = (tsk_id_t) self->nodes.num_rows;\n const tsk_id_t num_populations = (tsk_id_t) self->populations.num_rows;\n const bool check_population_refs = !(options & TSK_NO_CHECK_POPULATION_REFS);\n const bool check_migration_ordering = !!(options & TSK_CHECK_MIGRATION_ORDERING);\n\n for (j = 0; j < migrations.num_rows; j++) {\n if (migrations.node[j] < 0 || migrations.node[j] >= num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n if (check_population_refs) {\n if (migrations.source[j] < 0 || migrations.source[j] >= num_populations) {\n ret = tsk_trace_error(TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n goto out;\n }\n if (migrations.dest[j] < 0 || migrations.dest[j] >= num_populations) {\n ret = tsk_trace_error(TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n goto out;\n }\n }\n time = migrations.time[j];\n if (!tsk_isfinite(time)) {\n ret = tsk_trace_error(TSK_ERR_TIME_NONFINITE);\n goto out;\n }\n if (j > 0) {\n if (check_migration_ordering && migrations.time[j - 1] > time) {\n ret = tsk_trace_error(TSK_ERR_UNSORTED_MIGRATIONS);\n goto out;\n }\n }\n left = migrations.left[j];\n right = migrations.right[j];\n /* Spatial requirements */\n /* TODO it's a bit misleading to use the edge-specific errors here. */\n if (!(tsk_isfinite(left) && tsk_isfinite(right))) {\n ret = tsk_trace_error(TSK_ERR_GENOME_COORDS_NONFINITE);\n goto out;\n }\n if (left < 0) {\n ret = tsk_trace_error(TSK_ERR_LEFT_LESS_ZERO);\n goto out;\n }\n if (right > L) {\n ret = tsk_trace_error(TSK_ERR_RIGHT_GREATER_SEQ_LENGTH);\n goto out;\n }\n if (left >= right) {\n ret = tsk_trace_error(TSK_ERR_BAD_EDGE_INTERVAL);\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_table_collection_check_individual_integrity(\n const tsk_table_collection_t *self, tsk_flags_t options)\n{\n int ret = 0;\n tsk_size_t j, k;\n const tsk_individual_table_t individuals = self->individuals;\n const tsk_id_t num_individuals = (tsk_id_t) individuals.num_rows;\n const bool check_individual_ordering = options & TSK_CHECK_INDIVIDUAL_ORDERING;\n\n for (j = 0; j < (tsk_size_t) num_individuals; j++) {\n for (k = individuals.parents_offset[j]; k < individuals.parents_offset[j + 1];\n k++) {\n /* Check parent references are valid */\n if (individuals.parents[k] != TSK_NULL\n && (individuals.parents[k] < 0\n || individuals.parents[k] >= num_individuals)) {\n ret = tsk_trace_error(TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);\n goto out;\n }\n /* Check no-one is their own parent */\n if (individuals.parents[k] == (tsk_id_t) j) {\n ret = tsk_trace_error(TSK_ERR_INDIVIDUAL_SELF_PARENT);\n goto out;\n }\n /* Check parents are ordered */\n if (check_individual_ordering && individuals.parents[k] != TSK_NULL\n && individuals.parents[k] >= (tsk_id_t) j) {\n ret = tsk_trace_error(TSK_ERR_UNSORTED_INDIVIDUALS);\n goto out;\n }\n }\n }\nout:\n return ret;\n}\n\nstatic tsk_id_t TSK_WARN_UNUSED\ntsk_table_collection_check_tree_integrity(const tsk_table_collection_t *self)\n{\n tsk_id_t ret = 0;\n tsk_size_t j, k;\n tsk_id_t e, u, site, mutation;\n double tree_left, tree_right;\n const double sequence_length = self->sequence_length;\n const tsk_id_t num_sites = (tsk_id_t) self->sites.num_rows;\n const tsk_id_t num_mutations = (tsk_id_t) self->mutations.num_rows;\n const tsk_size_t num_edges = self->edges.num_rows;\n const double *restrict site_position = self->sites.position;\n const tsk_id_t *restrict mutation_site = self->mutations.site;\n const tsk_id_t *restrict mutation_node = self->mutations.node;\n const double *restrict mutation_time = self->mutations.time;\n const double *restrict node_time = self->nodes.time;\n const tsk_id_t *restrict I = self->indexes.edge_insertion_order;\n const tsk_id_t *restrict O = self->indexes.edge_removal_order;\n const double *restrict edge_right = self->edges.right;\n const double *restrict edge_left = self->edges.left;\n const tsk_id_t *restrict edge_child = self->edges.child;\n const tsk_id_t *restrict edge_parent = self->edges.parent;\n tsk_id_t *restrict parent = NULL;\n int8_t *restrict used_edges = NULL;\n tsk_id_t num_trees = 0;\n\n parent = tsk_malloc(self->nodes.num_rows * sizeof(*parent));\n used_edges = tsk_malloc(num_edges * sizeof(*used_edges));\n if (parent == NULL || used_edges == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(parent, 0xff, self->nodes.num_rows * sizeof(*parent));\n tsk_memset(used_edges, 0, num_edges * sizeof(*used_edges));\n\n tree_left = 0;\n num_trees = 0;\n j = 0;\n k = 0;\n site = 0;\n mutation = 0;\n tsk_bug_assert(I != NULL && O != NULL);\n tsk_bug_assert(self->indexes.num_edges == num_edges);\n\n while (j < num_edges || tree_left < sequence_length) {\n while (k < num_edges && edge_right[O[k]] == tree_left) {\n e = O[k];\n if (used_edges[e] != 1) {\n ret = tsk_trace_error(TSK_ERR_TABLES_BAD_INDEXES);\n goto out;\n }\n parent[edge_child[e]] = TSK_NULL;\n used_edges[e]++;\n k++;\n }\n while (j < num_edges && edge_left[I[j]] == tree_left) {\n e = I[j];\n if (used_edges[e] != 0) {\n ret = tsk_trace_error(TSK_ERR_TABLES_BAD_INDEXES);\n goto out;\n }\n used_edges[e]++;\n u = edge_child[e];\n if (parent[u] != TSK_NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_EDGES_CONTRADICTORY_CHILDREN);\n goto out;\n }\n parent[u] = edge_parent[e];\n j++;\n }\n tree_right = sequence_length;\n if (j < num_edges) {\n tree_right = TSK_MIN(tree_right, edge_left[I[j]]);\n }\n if (k < num_edges) {\n tree_right = TSK_MIN(tree_right, edge_right[O[k]]);\n }\n while (site < num_sites && site_position[site] < tree_right) {\n while (mutation < num_mutations && mutation_site[mutation] == site) {\n if (!tsk_is_unknown_time(mutation_time[mutation])\n && parent[mutation_node[mutation]] != TSK_NULL\n && node_time[parent[mutation_node[mutation]]]\n <= mutation_time[mutation]) {\n ret = tsk_trace_error(TSK_ERR_MUTATION_TIME_OLDER_THAN_PARENT_NODE);\n goto out;\n }\n mutation++;\n }\n site++;\n }\n if (tree_right <= tree_left) {\n ret = tsk_trace_error(TSK_ERR_TABLES_BAD_INDEXES);\n goto out;\n }\n tree_left = tree_right;\n /* This is technically possible; if we have 2**31 edges each defining\n * a single tree, and there's a gap between each of these edges we\n * would overflow this counter. */\n if (num_trees == TSK_MAX_ID) {\n ret = tsk_trace_error(TSK_ERR_TREE_OVERFLOW);\n goto out;\n }\n num_trees++;\n }\n tsk_bug_assert(j == num_edges);\n while (k < num_edges) {\n /* At this point it must be that used_edges[O[k]] == 1,\n * since otherwise we would have added a different edge twice,\n * and so hit the error above. */\n e = O[k];\n if (edge_right[e] != sequence_length) {\n ret = tsk_trace_error(TSK_ERR_TABLES_BAD_INDEXES);\n goto out;\n }\n used_edges[e]++;\n k++;\n }\n ret = num_trees;\nout:\n /* Can't use tsk_safe_free because of restrict*/\n if (parent != NULL) {\n free(parent);\n }\n if (used_edges != NULL) {\n free(used_edges);\n }\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_table_collection_check_index_integrity(const tsk_table_collection_t *self)\n{\n int ret = 0;\n tsk_id_t j;\n const tsk_id_t num_edges = (tsk_id_t) self->edges.num_rows;\n const tsk_id_t *edge_insertion_order = self->indexes.edge_insertion_order;\n const tsk_id_t *edge_removal_order = self->indexes.edge_removal_order;\n\n if (!tsk_table_collection_has_index(self, 0)) {\n ret = tsk_trace_error(TSK_ERR_TABLES_NOT_INDEXED);\n goto out;\n }\n for (j = 0; j < num_edges; j++) {\n if (edge_insertion_order[j] < 0 || edge_insertion_order[j] >= num_edges) {\n ret = tsk_trace_error(TSK_ERR_EDGE_OUT_OF_BOUNDS);\n goto out;\n }\n if (edge_removal_order[j] < 0 || edge_removal_order[j] >= num_edges) {\n ret = tsk_trace_error(TSK_ERR_EDGE_OUT_OF_BOUNDS);\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_table_collection_compute_mutation_parents_to_array(\n const tsk_table_collection_t *self, tsk_id_t *mutation_parent)\n{\n int ret = 0;\n const tsk_id_t *I, *O;\n const tsk_edge_table_t edges = self->edges;\n const tsk_node_table_t nodes = self->nodes;\n const tsk_site_table_t sites = self->sites;\n const tsk_mutation_table_t mutations = self->mutations;\n const tsk_id_t M = (tsk_id_t) edges.num_rows;\n tsk_id_t tj, tk;\n tsk_id_t *parent = NULL;\n tsk_id_t *bottom_mutation = NULL;\n tsk_id_t u;\n double left, right;\n tsk_id_t site;\n /* Using unsigned values here avoids potentially undefined behaviour */\n tsk_size_t j, mutation, first_mutation;\n\n parent = tsk_malloc(nodes.num_rows * sizeof(*parent));\n bottom_mutation = tsk_malloc(nodes.num_rows * sizeof(*bottom_mutation));\n if (parent == NULL || bottom_mutation == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(parent, 0xff, nodes.num_rows * sizeof(*parent));\n tsk_memset(bottom_mutation, 0xff, nodes.num_rows * sizeof(*bottom_mutation));\n tsk_memset(mutation_parent, 0xff, self->mutations.num_rows * sizeof(tsk_id_t));\n\n I = self->indexes.edge_insertion_order;\n O = self->indexes.edge_removal_order;\n tj = 0;\n tk = 0;\n site = 0;\n mutation = 0;\n left = 0;\n while (tj < M || left < self->sequence_length) {\n while (tk < M && edges.right[O[tk]] == left) {\n parent[edges.child[O[tk]]] = TSK_NULL;\n tk++;\n }\n while (tj < M && edges.left[I[tj]] == left) {\n parent[edges.child[I[tj]]] = edges.parent[I[tj]];\n tj++;\n }\n right = self->sequence_length;\n if (tj < M) {\n right = TSK_MIN(right, edges.left[I[tj]]);\n }\n if (tk < M) {\n right = TSK_MIN(right, edges.right[O[tk]]);\n }\n\n /* Tree is now ready. We look at each site on this tree in turn */\n while (site < (tsk_id_t) sites.num_rows && sites.position[site] < right) {\n /* Create a mapping from mutations to nodes. If we see more than one\n * mutation at a node, the previously seen one must be the parent\n * of the current since we assume they are in order. */\n first_mutation = mutation;\n while (mutation < mutations.num_rows && mutations.site[mutation] == site) {\n u = mutations.node[mutation];\n if (bottom_mutation[u] != TSK_NULL) {\n mutation_parent[mutation] = bottom_mutation[u];\n }\n bottom_mutation[u] = (tsk_id_t) mutation;\n mutation++;\n }\n /* Make the common case of 1 mutation fast */\n if (mutation > first_mutation + 1) {\n /* If we have more than one mutation, compute the parent for each\n * one by traversing up the tree until we find a node that has a\n * mutation. */\n for (j = first_mutation; j < mutation; j++) {\n if (mutation_parent[j] == TSK_NULL) {\n u = parent[mutations.node[j]];\n while (u != TSK_NULL && bottom_mutation[u] == TSK_NULL) {\n u = parent[u];\n }\n if (u != TSK_NULL) {\n mutation_parent[j] = bottom_mutation[u];\n }\n }\n }\n }\n /* Reset the mapping for the next site */\n for (j = first_mutation; j < mutation; j++) {\n u = mutations.node[j];\n bottom_mutation[u] = TSK_NULL;\n /* Check that we haven't violated the sortedness property */\n if (mutation_parent[j] > (tsk_id_t) j) {\n ret = tsk_trace_error(TSK_ERR_MUTATION_PARENT_AFTER_CHILD);\n goto out;\n }\n }\n site++;\n }\n /* Move on to the next tree */\n left = right;\n }\n\nout:\n tsk_safe_free(parent);\n tsk_safe_free(bottom_mutation);\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_table_collection_check_mutation_parents(const tsk_table_collection_t *self)\n{\n int ret = 0;\n tsk_mutation_table_t mutations = self->mutations;\n tsk_id_t *new_parents = NULL;\n tsk_size_t j;\n\n if (mutations.num_rows == 0) {\n return ret;\n }\n\n new_parents = tsk_malloc(mutations.num_rows * sizeof(*new_parents));\n if (new_parents == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n ret = tsk_table_collection_compute_mutation_parents_to_array(self, new_parents);\n if (ret != 0) {\n goto out;\n }\n\n for (j = 0; j < mutations.num_rows; j++) {\n if (mutations.parent[j] != new_parents[j]) {\n ret = tsk_trace_error(TSK_ERR_BAD_MUTATION_PARENT);\n goto out;\n }\n }\n\nout:\n tsk_safe_free(new_parents);\n return ret;\n}\n\ntsk_id_t TSK_WARN_UNUSED\ntsk_table_collection_check_integrity(\n const tsk_table_collection_t *self, tsk_flags_t options)\n{\n tsk_id_t ret = 0;\n int mut_ret = 0;\n\n if (options & TSK_CHECK_MUTATION_PARENTS) {\n /* If we're checking mutation parents, we need to check the trees first */\n options |= TSK_CHECK_TREES;\n }\n\n if (options & TSK_CHECK_TREES) {\n /* Checking the trees implies these checks */\n options |= TSK_CHECK_EDGE_ORDERING | TSK_CHECK_SITE_ORDERING\n | TSK_CHECK_SITE_DUPLICATES | TSK_CHECK_MUTATION_ORDERING\n | TSK_CHECK_MIGRATION_ORDERING | TSK_CHECK_INDEXES;\n }\n\n if (!tsk_isfinite(self->sequence_length) || self->sequence_length <= 0) {\n ret = tsk_trace_error(TSK_ERR_BAD_SEQUENCE_LENGTH);\n goto out;\n }\n ret = tsk_table_collection_check_offsets(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_check_node_integrity(self, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_check_edge_integrity(self, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_check_site_integrity(self, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_check_mutation_integrity(self, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_check_migration_integrity(self, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_check_individual_integrity(self, options);\n if (ret != 0) {\n goto out;\n }\n\n if (options & TSK_CHECK_INDEXES) {\n ret = tsk_table_collection_check_index_integrity(self);\n if (ret != 0) {\n goto out;\n }\n }\n if (options & TSK_CHECK_TREES) {\n ret = tsk_table_collection_check_tree_integrity(self);\n if (ret < 0) {\n goto out;\n }\n /* This check requires tree integrity so do it last */\n if (options & TSK_CHECK_MUTATION_PARENTS) {\n mut_ret = tsk_table_collection_check_mutation_parents(self);\n if (mut_ret != 0) {\n ret = mut_ret;\n goto out;\n }\n }\n }\nout:\n return ret;\n}\n\nvoid\ntsk_table_collection_print_state(const tsk_table_collection_t *self, FILE *out)\n{\n fprintf(out, \"Table collection state\\n\");\n fprintf(out, \"sequence_length = %f\\n\", self->sequence_length);\n\n write_metadata_schema_header(\n out, self->metadata_schema, self->metadata_schema_length);\n fprintf(out, \"#metadata#\\n\");\n fprintf(out, \"%.*s\\n\", (int) self->metadata_length, self->metadata);\n fprintf(out, \"#end#metadata\\n\");\n fprintf(out, \"#time_units#\\n\");\n fprintf(out, \"%.*s\\n\", (int) self->time_units_length, self->time_units);\n fprintf(out, \"#end#time_units\\n\");\n tsk_individual_table_print_state(&self->individuals, out);\n tsk_node_table_print_state(&self->nodes, out);\n tsk_edge_table_print_state(&self->edges, out);\n tsk_migration_table_print_state(&self->migrations, out);\n tsk_site_table_print_state(&self->sites, out);\n tsk_mutation_table_print_state(&self->mutations, out);\n tsk_population_table_print_state(&self->populations, out);\n tsk_provenance_table_print_state(&self->provenances, out);\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_init(tsk_table_collection_t *self, tsk_flags_t options)\n{\n int ret = 0;\n tsk_flags_t edge_options = 0;\n\n tsk_memset(self, 0, sizeof(*self));\n if (options & TSK_TC_NO_EDGE_METADATA) {\n edge_options |= TSK_TABLE_NO_METADATA;\n }\n\n /* Set default time_units value */\n ret = tsk_table_collection_set_time_units(\n self, TSK_TIME_UNITS_UNKNOWN, strlen(TSK_TIME_UNITS_UNKNOWN));\n if (ret != 0) {\n goto out;\n }\n\n ret = tsk_node_table_init(&self->nodes, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_edge_table_init(&self->edges, edge_options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_migration_table_init(&self->migrations, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_site_table_init(&self->sites, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_mutation_table_init(&self->mutations, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_individual_table_init(&self->individuals, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_population_table_init(&self->populations, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_provenance_table_init(&self->provenances, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_reference_sequence_init(&self->reference_sequence, 0);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nint\ntsk_table_collection_free(tsk_table_collection_t *self)\n{\n tsk_individual_table_free(&self->individuals);\n tsk_node_table_free(&self->nodes);\n tsk_edge_table_free(&self->edges);\n tsk_migration_table_free(&self->migrations);\n tsk_site_table_free(&self->sites);\n tsk_mutation_table_free(&self->mutations);\n tsk_population_table_free(&self->populations);\n tsk_provenance_table_free(&self->provenances);\n tsk_reference_sequence_free(&self->reference_sequence);\n tsk_safe_free(self->indexes.edge_insertion_order);\n tsk_safe_free(self->indexes.edge_removal_order);\n tsk_safe_free(self->file_uuid);\n tsk_safe_free(self->time_units);\n tsk_safe_free(self->metadata);\n tsk_safe_free(self->metadata_schema);\n return 0;\n}\n\nbool\ntsk_table_collection_equals(const tsk_table_collection_t *self,\n const tsk_table_collection_t *other, tsk_flags_t options)\n{\n bool ret = self->sequence_length == other->sequence_length\n && self->time_units_length == other->time_units_length\n && tsk_memcmp(self->time_units, other->time_units,\n self->time_units_length * sizeof(char))\n == 0;\n if (!(options & TSK_CMP_IGNORE_TABLES)) {\n ret = ret\n && tsk_individual_table_equals(\n &self->individuals, &other->individuals, options)\n && tsk_node_table_equals(&self->nodes, &other->nodes, options)\n && tsk_edge_table_equals(&self->edges, &other->edges, options)\n && tsk_migration_table_equals(\n &self->migrations, &other->migrations, options)\n && tsk_site_table_equals(&self->sites, &other->sites, options)\n && tsk_mutation_table_equals(&self->mutations, &other->mutations, options)\n && tsk_population_table_equals(\n &self->populations, &other->populations, options);\n /* TSK_CMP_IGNORE_TABLES implies TSK_CMP_IGNORE_PROVENANCE */\n if (!(options & TSK_CMP_IGNORE_PROVENANCE)) {\n ret = ret\n && tsk_provenance_table_equals(\n &self->provenances, &other->provenances, options);\n }\n }\n /* TSK_CMP_IGNORE_TS_METADATA is implied by TSK_CMP_IGNORE_METADATA */\n if (options & TSK_CMP_IGNORE_METADATA) {\n options |= TSK_CMP_IGNORE_TS_METADATA;\n }\n if (!(options & TSK_CMP_IGNORE_TS_METADATA)) {\n ret = ret\n && (self->metadata_length == other->metadata_length\n && self->metadata_schema_length == other->metadata_schema_length\n && tsk_memcmp(self->metadata, other->metadata,\n self->metadata_length * sizeof(char))\n == 0\n && tsk_memcmp(self->metadata_schema, other->metadata_schema,\n self->metadata_schema_length * sizeof(char))\n == 0);\n }\n\n if (!(options & TSK_CMP_IGNORE_REFERENCE_SEQUENCE)) {\n ret = ret\n && tsk_reference_sequence_equals(\n &self->reference_sequence, &other->reference_sequence, options);\n }\n return ret;\n}\n\nint\ntsk_table_collection_set_time_units(\n tsk_table_collection_t *self, const char *time_units, tsk_size_t time_units_length)\n{\n return replace_string(\n &self->time_units, &self->time_units_length, time_units, time_units_length);\n}\n\nint\ntsk_table_collection_set_metadata(\n tsk_table_collection_t *self, const char *metadata, tsk_size_t metadata_length)\n{\n return replace_string(\n &self->metadata, &self->metadata_length, metadata, metadata_length);\n}\n\nint\ntsk_table_collection_takeset_metadata(\n tsk_table_collection_t *self, char *metadata, tsk_size_t metadata_length)\n{\n return takeset_string(\n &self->metadata, &self->metadata_length, metadata, metadata_length);\n}\n\nint\ntsk_table_collection_set_metadata_schema(tsk_table_collection_t *self,\n const char *metadata_schema, tsk_size_t metadata_schema_length)\n{\n return replace_string(&self->metadata_schema, &self->metadata_schema_length,\n metadata_schema, metadata_schema_length);\n}\n\nint\ntsk_table_collection_set_indexes(tsk_table_collection_t *self,\n tsk_id_t *edge_insertion_order, tsk_id_t *edge_removal_order)\n{\n int ret = 0;\n tsk_size_t index_size = self->edges.num_rows * sizeof(tsk_id_t);\n\n tsk_table_collection_drop_index(self, 0);\n self->indexes.edge_insertion_order = tsk_malloc(index_size);\n self->indexes.edge_removal_order = tsk_malloc(index_size);\n if (self->indexes.edge_insertion_order == NULL\n || self->indexes.edge_removal_order == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memcpy(self->indexes.edge_insertion_order, edge_insertion_order, index_size);\n tsk_memcpy(self->indexes.edge_removal_order, edge_removal_order, index_size);\n self->indexes.num_edges = self->edges.num_rows;\nout:\n return ret;\n}\n\nint\ntsk_table_collection_takeset_indexes(tsk_table_collection_t *self,\n tsk_id_t *edge_insertion_order, tsk_id_t *edge_removal_order)\n{\n int ret = 0;\n\n if (edge_insertion_order == NULL || edge_removal_order == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n tsk_table_collection_drop_index(self, 0);\n self->indexes.edge_insertion_order = edge_insertion_order;\n self->indexes.edge_removal_order = edge_removal_order;\n self->indexes.num_edges = self->edges.num_rows;\nout:\n return ret;\n}\n\nbool\ntsk_table_collection_has_index(\n const tsk_table_collection_t *self, tsk_flags_t TSK_UNUSED(options))\n{\n return self->indexes.edge_insertion_order != NULL\n && self->indexes.edge_removal_order != NULL\n && self->indexes.num_edges == self->edges.num_rows;\n}\n\nbool\ntsk_table_collection_has_reference_sequence(const tsk_table_collection_t *self)\n{\n return !tsk_reference_sequence_is_null(&self->reference_sequence);\n}\n\nint\ntsk_table_collection_drop_index(\n tsk_table_collection_t *self, tsk_flags_t TSK_UNUSED(options))\n{\n tsk_safe_free(self->indexes.edge_insertion_order);\n tsk_safe_free(self->indexes.edge_removal_order);\n self->indexes.edge_insertion_order = NULL;\n self->indexes.edge_removal_order = NULL;\n self->indexes.num_edges = 0;\n return 0;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_build_index(\n tsk_table_collection_t *self, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = TSK_ERR_GENERIC;\n tsk_id_t ret_id;\n tsk_size_t j;\n double *time = self->nodes.time;\n index_sort_t *sort_buff = NULL;\n tsk_id_t parent;\n\n /* For build indexes to make sense we must have referential integrity and\n * sorted edges */\n ret_id = tsk_table_collection_check_integrity(self, TSK_CHECK_EDGE_ORDERING);\n if (ret_id != 0) {\n ret = (int) ret_id;\n goto out;\n }\n\n tsk_table_collection_drop_index(self, 0);\n self->indexes.edge_insertion_order\n = tsk_malloc(self->edges.num_rows * sizeof(tsk_id_t));\n self->indexes.edge_removal_order\n = tsk_malloc(self->edges.num_rows * sizeof(tsk_id_t));\n sort_buff = tsk_malloc(self->edges.num_rows * sizeof(index_sort_t));\n if (self->indexes.edge_insertion_order == NULL\n || self->indexes.edge_removal_order == NULL || sort_buff == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n /* sort by left and increasing time to give us the order in which\n * records should be inserted */\n for (j = 0; j < self->edges.num_rows; j++) {\n sort_buff[j].index = (tsk_id_t) j;\n sort_buff[j].first = self->edges.left[j];\n parent = self->edges.parent[j];\n sort_buff[j].second = time[parent];\n sort_buff[j].third = parent;\n sort_buff[j].fourth = self->edges.child[j];\n }\n qsort(\n sort_buff, (size_t) self->edges.num_rows, sizeof(index_sort_t), cmp_index_sort);\n for (j = 0; j < self->edges.num_rows; j++) {\n self->indexes.edge_insertion_order[j] = sort_buff[j].index;\n }\n /* sort by right and decreasing parent time to give us the order in which\n * records should be removed. */\n for (j = 0; j < self->edges.num_rows; j++) {\n sort_buff[j].index = (tsk_id_t) j;\n sort_buff[j].first = self->edges.right[j];\n parent = self->edges.parent[j];\n sort_buff[j].second = -time[parent];\n sort_buff[j].third = -parent;\n sort_buff[j].fourth = -self->edges.child[j];\n }\n qsort(\n sort_buff, (size_t) self->edges.num_rows, sizeof(index_sort_t), cmp_index_sort);\n for (j = 0; j < self->edges.num_rows; j++) {\n self->indexes.edge_removal_order[j] = sort_buff[j].index;\n }\n self->indexes.num_edges = self->edges.num_rows;\n ret = 0;\nout:\n tsk_safe_free(sort_buff);\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_table_collection_set_file_uuid(tsk_table_collection_t *self, const char *uuid)\n{\n int ret = 0;\n\n tsk_safe_free(self->file_uuid);\n self->file_uuid = NULL;\n\n if (uuid != NULL) {\n /* Allow space for \\0 so we can print it as a string */\n self->file_uuid = tsk_malloc(TSK_UUID_SIZE + 1);\n if (self->file_uuid == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memcpy(self->file_uuid, uuid, TSK_UUID_SIZE);\n self->file_uuid[TSK_UUID_SIZE] = '\\0';\n }\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_copy(const tsk_table_collection_t *self,\n tsk_table_collection_t *dest, tsk_flags_t options)\n{\n int ret = 0;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_table_collection_init(dest, options);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_node_table_copy(&self->nodes, &dest->nodes, TSK_NO_INIT);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_edge_table_copy(&self->edges, &dest->edges, TSK_NO_INIT);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_migration_table_copy(&self->migrations, &dest->migrations, TSK_NO_INIT);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_site_table_copy(&self->sites, &dest->sites, TSK_NO_INIT);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_mutation_table_copy(&self->mutations, &dest->mutations, TSK_NO_INIT);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_individual_table_copy(&self->individuals, &dest->individuals, TSK_NO_INIT);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_population_table_copy(&self->populations, &dest->populations, TSK_NO_INIT);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_provenance_table_copy(&self->provenances, &dest->provenances, TSK_NO_INIT);\n if (ret != 0) {\n goto out;\n }\n dest->sequence_length = self->sequence_length;\n if (tsk_table_collection_has_index(self, 0)) {\n ret = tsk_table_collection_set_indexes(\n dest, self->indexes.edge_insertion_order, self->indexes.edge_removal_order);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_table_collection_set_time_units(\n dest, self->time_units, self->time_units_length);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_set_metadata(dest, self->metadata, self->metadata_length);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_set_metadata_schema(\n dest, self->metadata_schema, self->metadata_schema_length);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_reference_sequence_copy(\n &self->reference_sequence, &dest->reference_sequence, options);\n if (ret != 0) {\n goto out;\n }\n if (options & TSK_COPY_FILE_UUID) {\n /* The UUID should only be generated on writing to a file (see the call\n * to generate_uuid in tsk_table_collection_write_format_data) and\n * no other writing access is supported. We only read the value from\n * the file, and raise an error if it's the wrong length there. Thus,\n * finding a UUID value of any other length here is undefined behaviour.\n */\n tsk_bug_assert(\n self->file_uuid == NULL || strlen(self->file_uuid) == TSK_UUID_SIZE);\n ret = tsk_table_collection_set_file_uuid(dest, self->file_uuid);\n if (ret != 0) {\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_table_collection_read_format_data(tsk_table_collection_t *self, kastore_t *store)\n{\n int ret = 0;\n size_t len;\n uint32_t *version = NULL;\n int8_t *format_name = NULL;\n int8_t *uuid = NULL;\n double *L = NULL;\n char *time_units = NULL;\n char *metadata = NULL;\n char *metadata_schema = NULL;\n size_t time_units_length, metadata_length, metadata_schema_length;\n /* TODO we could simplify this function quite a bit if we use the\n * read_table_properties infrastructure. We would need to add the\n * ability to have non-optional columns to that though. */\n\n ret = kastore_gets_int8(store, \"format/name\", &format_name, &len);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n if (len != TSK_FILE_FORMAT_NAME_LENGTH) {\n ret = tsk_trace_error(TSK_ERR_FILE_FORMAT);\n goto out;\n }\n if (tsk_memcmp(TSK_FILE_FORMAT_NAME, format_name, TSK_FILE_FORMAT_NAME_LENGTH)\n != 0) {\n ret = tsk_trace_error(TSK_ERR_FILE_FORMAT);\n goto out;\n }\n\n ret = kastore_gets_uint32(store, \"format/version\", &version, &len);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n if (len != 2) {\n ret = tsk_trace_error(TSK_ERR_FILE_FORMAT);\n goto out;\n }\n if (version[0] < TSK_FILE_FORMAT_VERSION_MAJOR) {\n ret = tsk_trace_error(TSK_ERR_FILE_VERSION_TOO_OLD);\n goto out;\n }\n if (version[0] > TSK_FILE_FORMAT_VERSION_MAJOR) {\n ret = tsk_trace_error(TSK_ERR_FILE_VERSION_TOO_NEW);\n goto out;\n }\n\n ret = kastore_gets_float64(store, \"sequence_length\", &L, &len);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n if (len != 1) {\n ret = tsk_trace_error(TSK_ERR_FILE_FORMAT);\n goto out;\n }\n if (L[0] <= 0.0) {\n ret = tsk_trace_error(TSK_ERR_BAD_SEQUENCE_LENGTH);\n goto out;\n }\n self->sequence_length = L[0];\n\n ret = kastore_gets_int8(store, \"uuid\", &uuid, &len);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n if (len != TSK_UUID_SIZE) {\n ret = tsk_trace_error(TSK_ERR_FILE_FORMAT);\n goto out;\n }\n ret = tsk_table_collection_set_file_uuid(self, (const char *) uuid);\n if (ret != 0) {\n goto out;\n }\n\n ret = kastore_containss(store, \"time_units\");\n if (ret < 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n if (ret == 1) {\n ret = kastore_gets_int8(\n store, \"time_units\", (int8_t **) &time_units, &time_units_length);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n ret = tsk_table_collection_set_time_units(\n self, time_units, (tsk_size_t) time_units_length);\n if (ret != 0) {\n goto out;\n }\n }\n ret = kastore_containss(store, \"metadata\");\n if (ret < 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n if (ret == 1) {\n ret = kastore_gets_int8(\n store, \"metadata\", (int8_t **) &metadata, &metadata_length);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n ret = tsk_table_collection_takeset_metadata(\n self, metadata, (tsk_size_t) metadata_length);\n if (ret != 0) {\n goto out;\n }\n metadata = NULL;\n }\n\n ret = kastore_containss(store, \"metadata_schema\");\n if (ret < 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n if (ret == 1) {\n ret = kastore_gets_int8(store, \"metadata_schema\", (int8_t **) &metadata_schema,\n (size_t *) &metadata_schema_length);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n ret = tsk_table_collection_set_metadata_schema(\n self, metadata_schema, (tsk_size_t) metadata_schema_length);\n if (ret != 0) {\n goto out;\n }\n }\n\nout:\n if ((ret ^ (1 << TSK_KAS_ERR_BIT)) == KAS_ERR_KEY_NOT_FOUND) {\n ret = tsk_trace_error(TSK_ERR_REQUIRED_COL_NOT_FOUND);\n }\n tsk_safe_free(version);\n tsk_safe_free(format_name);\n tsk_safe_free(uuid);\n tsk_safe_free(L);\n tsk_safe_free(time_units);\n tsk_safe_free(metadata_schema);\n tsk_safe_free(metadata);\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_table_collection_dump_indexes(const tsk_table_collection_t *self, kastore_t *store,\n tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n write_table_col_t cols[] = {\n { \"indexes/edge_insertion_order\", NULL, self->indexes.num_edges,\n TSK_ID_STORAGE_TYPE },\n { \"indexes/edge_removal_order\", NULL, self->indexes.num_edges,\n TSK_ID_STORAGE_TYPE },\n { .name = NULL },\n };\n\n if (tsk_table_collection_has_index(self, 0)) {\n cols[0].array = self->indexes.edge_insertion_order;\n cols[1].array = self->indexes.edge_removal_order;\n ret = write_table_cols(store, cols, 0);\n }\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_table_collection_load_indexes(tsk_table_collection_t *self, kastore_t *store)\n{\n int ret = 0;\n tsk_id_t *edge_insertion_order = NULL;\n tsk_id_t *edge_removal_order = NULL;\n tsk_size_t num_rows;\n\n read_table_col_t cols[] = {\n { \"indexes/edge_insertion_order\", (void **) &edge_insertion_order,\n TSK_ID_STORAGE_TYPE, TSK_COL_OPTIONAL },\n { \"indexes/edge_removal_order\", (void **) &edge_removal_order,\n TSK_ID_STORAGE_TYPE, TSK_COL_OPTIONAL },\n { .name = NULL },\n };\n\n num_rows = TSK_NUM_ROWS_UNSET;\n ret = read_table_cols(store, &num_rows, cols, 0);\n if (ret != 0) {\n goto out;\n }\n\n if ((edge_insertion_order == NULL) != (edge_removal_order == NULL)) {\n ret = tsk_trace_error(TSK_ERR_BOTH_COLUMNS_REQUIRED);\n goto out;\n }\n if (edge_insertion_order != NULL) {\n if (num_rows != self->edges.num_rows) {\n ret = tsk_trace_error(TSK_ERR_FILE_FORMAT);\n goto out;\n }\n ret = tsk_table_collection_takeset_indexes(\n self, edge_insertion_order, edge_removal_order);\n if (ret != 0) {\n goto out;\n }\n }\n edge_insertion_order = NULL;\n edge_removal_order = NULL;\nout:\n tsk_safe_free(edge_insertion_order);\n tsk_safe_free(edge_removal_order);\n return ret;\n}\n\nstatic int\ntsk_table_collection_load_reference_sequence(\n tsk_table_collection_t *self, kastore_t *store)\n{\n int ret = 0;\n char *data = NULL;\n char *url = NULL;\n char *metadata = NULL;\n char *metadata_schema = NULL;\n tsk_size_t data_length = 0, url_length, metadata_length, metadata_schema_length;\n\n read_table_property_t properties[] = {\n { \"reference_sequence/data\", (void **) &data, &data_length, KAS_UINT8,\n TSK_COL_OPTIONAL },\n { \"reference_sequence/url\", (void **) &url, &url_length, KAS_UINT8,\n TSK_COL_OPTIONAL },\n { \"reference_sequence/metadata\", (void **) &metadata, &metadata_length,\n KAS_UINT8, TSK_COL_OPTIONAL },\n { \"reference_sequence/metadata_schema\", (void **) &metadata_schema,\n &metadata_schema_length, KAS_UINT8, TSK_COL_OPTIONAL },\n { .name = NULL },\n };\n\n ret = read_table_properties(store, properties, 0);\n if (ret != 0) {\n goto out;\n }\n if (data != NULL) {\n ret = tsk_reference_sequence_takeset_data(\n &self->reference_sequence, data, (tsk_size_t) data_length);\n if (ret != 0) {\n goto out;\n }\n data = NULL;\n }\n if (metadata != NULL) {\n ret = tsk_reference_sequence_takeset_metadata(\n &self->reference_sequence, metadata, (tsk_size_t) metadata_length);\n if (ret != 0) {\n goto out;\n }\n metadata = NULL;\n }\n if (metadata_schema != NULL) {\n ret = tsk_reference_sequence_set_metadata_schema(&self->reference_sequence,\n metadata_schema, (tsk_size_t) metadata_schema_length);\n if (ret != 0) {\n goto out;\n }\n }\n if (url != NULL) {\n ret = tsk_reference_sequence_set_url(\n &self->reference_sequence, url, (tsk_size_t) url_length);\n if (ret != 0) {\n goto out;\n }\n }\n\nout:\n free_read_table_mem(NULL, NULL, properties);\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_table_collection_loadf_inited(\n tsk_table_collection_t *self, FILE *file, tsk_flags_t options)\n{\n int ret = 0;\n kastore_t store;\n\n int kas_flags = KAS_READ_ALL;\n if ((options & TSK_LOAD_SKIP_TABLES)\n || (options & TSK_LOAD_SKIP_REFERENCE_SEQUENCE)) {\n kas_flags = 0;\n }\n kas_flags = kas_flags | KAS_GET_TAKES_OWNERSHIP;\n ret = kastore_openf(&store, file, \"r\", kas_flags);\n\n if (ret != 0) {\n if (ret == KAS_ERR_EOF) {\n /* KAS_ERR_EOF means that we tried to read a store from the stream\n * and we hit EOF immediately without reading any bytes. We signal\n * this back to the client, which allows it to read an indefinite\n * number of stores from a stream */\n ret = tsk_trace_error(TSK_ERR_EOF);\n } else {\n ret = tsk_set_kas_error(ret);\n }\n goto out;\n }\n ret = tsk_table_collection_read_format_data(self, &store);\n if (ret != 0) {\n goto out;\n }\n if (!(options & TSK_LOAD_SKIP_TABLES)) {\n ret = tsk_node_table_load(&self->nodes, &store);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_edge_table_load(&self->edges, &store);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_site_table_load(&self->sites, &store);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_mutation_table_load(&self->mutations, &store);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_migration_table_load(&self->migrations, &store);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_individual_table_load(&self->individuals, &store);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_population_table_load(&self->populations, &store);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_provenance_table_load(&self->provenances, &store);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_load_indexes(self, &store);\n if (ret != 0) {\n goto out;\n }\n } else {\n ret = tsk_table_collection_build_index(self, 0);\n if (ret != 0) {\n goto out;\n }\n }\n if (!(options & TSK_LOAD_SKIP_REFERENCE_SEQUENCE)) {\n ret = tsk_table_collection_load_reference_sequence(self, &store);\n if (ret != 0) {\n goto out;\n }\n }\n ret = kastore_close(&store);\n if (ret != 0) {\n goto out;\n }\nout:\n /* If we're exiting on an error, we ignore any further errors that might come\n * from kastore. In the nominal case, closing an already-closed store is a\n * safe noop */\n kastore_close(&store);\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_loadf(tsk_table_collection_t *self, FILE *file, tsk_flags_t options)\n{\n int ret = 0;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_table_collection_init(self, options);\n if (ret != 0) {\n goto out;\n }\n }\n ret = tsk_table_collection_loadf_inited(self, file, options);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_load(\n tsk_table_collection_t *self, const char *filename, tsk_flags_t options)\n{\n int ret = 0;\n FILE *file = NULL;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_table_collection_init(self, options);\n if (ret != 0) {\n goto out;\n }\n }\n file = fopen(filename, \"rb\");\n if (file == NULL) {\n ret = tsk_trace_error(TSK_ERR_IO);\n goto out;\n }\n ret = tsk_table_collection_loadf_inited(self, file, options);\n if (ret != 0) {\n goto out;\n }\n if (fclose(file) != 0) {\n ret = tsk_trace_error(TSK_ERR_IO);\n goto out;\n }\n file = NULL;\nout:\n if (file != NULL) {\n /* Ignore any additional errors we might get when closing the file\n * in error conditions */\n fclose(file);\n }\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_table_collection_dump_reference_sequence(const tsk_table_collection_t *self,\n kastore_t *store, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n const tsk_reference_sequence_t *ref = &self->reference_sequence;\n write_table_col_t write_cols[] = {\n { \"reference_sequence/data\", (void *) ref->data, ref->data_length, KAS_UINT8 },\n { \"reference_sequence/url\", (void *) ref->url, ref->url_length, KAS_UINT8 },\n { \"reference_sequence/metadata\", (void *) ref->metadata, ref->metadata_length,\n KAS_UINT8 },\n { \"reference_sequence/metadata_schema\", (void *) ref->metadata_schema,\n ref->metadata_schema_length, KAS_UINT8 },\n { .name = NULL },\n };\n if (tsk_table_collection_has_reference_sequence(self)) {\n ret = write_table_cols(store, write_cols, 0);\n }\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_dump(\n const tsk_table_collection_t *self, const char *filename, tsk_flags_t options)\n{\n int ret = 0;\n FILE *file = fopen(filename, \"wb\");\n\n if (file == NULL) {\n ret = tsk_trace_error(TSK_ERR_IO);\n goto out;\n }\n ret = tsk_table_collection_dumpf(self, file, options);\n if (ret != 0) {\n goto out;\n }\n if (fclose(file) != 0) {\n ret = tsk_trace_error(TSK_ERR_IO);\n goto out;\n }\n file = NULL;\nout:\n if (file != NULL) {\n /* Ignore any additional errors we might get when closing the file\n * in error conditions */\n fclose(file);\n /* If an error occurred make sure that the filename is removed */\n remove(filename);\n }\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_dumpf(\n const tsk_table_collection_t *self, FILE *file, tsk_flags_t options)\n{\n int ret = 0;\n kastore_t store;\n char uuid[TSK_UUID_SIZE + 1]; // Must include space for trailing null.\n write_table_col_t format_columns[] = {\n { \"format/name\", (const void *) &TSK_FILE_FORMAT_NAME,\n TSK_FILE_FORMAT_NAME_LENGTH, KAS_INT8 },\n { \"format/version\",\n (const void *) &(uint32_t[]) {\n TSK_FILE_FORMAT_VERSION_MAJOR, TSK_FILE_FORMAT_VERSION_MINOR },\n 2, KAS_UINT32 },\n { \"sequence_length\", (const void *) &self->sequence_length, 1, KAS_FLOAT64 },\n { \"uuid\", (void *) uuid, TSK_UUID_SIZE, KAS_INT8 },\n { \"time_units\", (void *) self->time_units, self->time_units_length, KAS_INT8 },\n { \"metadata\", (void *) self->metadata, self->metadata_length, KAS_INT8 },\n { \"metadata_schema\", (void *) self->metadata_schema,\n self->metadata_schema_length, KAS_INT8 },\n { .name = NULL },\n };\n\n tsk_memset(&store, 0, sizeof(store));\n\n ret = kastore_openf(&store, file, \"w\", 0);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\n\n /* Write format data */\n ret = tsk_generate_uuid(uuid, 0);\n if (ret != 0) {\n goto out;\n }\n\n ret = write_table_cols(&store, format_columns, options);\n if (ret != 0) {\n goto out;\n }\n\n /* All of these functions will set the kas_error internally, so we don't have\n * to modify the return value. */\n ret = tsk_node_table_dump(&self->nodes, &store, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_edge_table_dump(&self->edges, &store, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_site_table_dump(&self->sites, &store, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_migration_table_dump(&self->migrations, &store, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_mutation_table_dump(&self->mutations, &store, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_individual_table_dump(&self->individuals, &store, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_population_table_dump(&self->populations, &store, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_provenance_table_dump(&self->provenances, &store, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_dump_indexes(self, &store, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_dump_reference_sequence(self, &store, options);\n if (ret != 0) {\n goto out;\n }\n\n ret = kastore_close(&store);\n if (ret != 0) {\n ret = tsk_set_kas_error(ret);\n goto out;\n }\nout:\n /* It's safe to close a kastore twice. */\n if (ret != 0) {\n kastore_close(&store);\n }\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_simplify(tsk_table_collection_t *self, const tsk_id_t *samples,\n tsk_size_t num_samples, tsk_flags_t options, tsk_id_t *node_map)\n{\n int ret = 0;\n simplifier_t simplifier;\n tsk_id_t *local_samples = NULL;\n tsk_id_t u;\n\n /* Avoid calling to simplifier_free with uninit'd memory on error branches */\n tsk_memset(&simplifier, 0, sizeof(simplifier_t));\n\n if ((options & TSK_SIMPLIFY_KEEP_UNARY)\n && (options & TSK_SIMPLIFY_KEEP_UNARY_IN_INDIVIDUALS)) {\n ret = tsk_trace_error(TSK_ERR_KEEP_UNARY_MUTUALLY_EXCLUSIVE);\n goto out;\n }\n\n /* For now we don't bother with edge metadata, but it can easily be\n * implemented. */\n if (self->edges.metadata_length > 0) {\n ret = tsk_trace_error(TSK_ERR_CANT_PROCESS_EDGES_WITH_METADATA);\n goto out;\n }\n\n if (samples == NULL) {\n local_samples = tsk_malloc(self->nodes.num_rows * sizeof(*local_samples));\n if (local_samples == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n num_samples = 0;\n for (u = 0; u < (tsk_id_t) self->nodes.num_rows; u++) {\n if (!!(self->nodes.flags[u] & TSK_NODE_IS_SAMPLE)) {\n local_samples[num_samples] = u;\n num_samples++;\n }\n }\n samples = local_samples;\n }\n\n ret = simplifier_init(&simplifier, samples, num_samples, self, options);\n if (ret != 0) {\n goto out;\n }\n ret = simplifier_run(&simplifier, node_map);\n if (ret != 0) {\n goto out;\n }\n if (!!(options & TSK_DEBUG)) {\n simplifier_print_state(&simplifier, tsk_get_debug_stream());\n }\n /* The indexes are invalidated now so drop them */\n ret = tsk_table_collection_drop_index(self, 0);\nout:\n simplifier_free(&simplifier);\n tsk_safe_free(local_samples);\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_link_ancestors(tsk_table_collection_t *self, tsk_id_t *samples,\n tsk_size_t num_samples, tsk_id_t *ancestors, tsk_size_t num_ancestors,\n tsk_flags_t TSK_UNUSED(options), tsk_edge_table_t *result)\n{\n int ret = 0;\n ancestor_mapper_t ancestor_mapper;\n\n tsk_memset(&ancestor_mapper, 0, sizeof(ancestor_mapper_t));\n\n if (self->edges.metadata_length > 0) {\n ret = tsk_trace_error(TSK_ERR_CANT_PROCESS_EDGES_WITH_METADATA);\n goto out;\n }\n\n ret = ancestor_mapper_init(\n &ancestor_mapper, samples, num_samples, ancestors, num_ancestors, self, result);\n if (ret != 0) {\n goto out;\n }\n ret = ancestor_mapper_run(&ancestor_mapper);\n if (ret != 0) {\n goto out;\n }\nout:\n ancestor_mapper_free(&ancestor_mapper);\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_ibd_within(const tsk_table_collection_t *self,\n tsk_identity_segments_t *result, const tsk_id_t *samples, tsk_size_t num_samples,\n double min_span, double max_time, tsk_flags_t options)\n{\n int ret = 0;\n tsk_ibd_finder_t ibd_finder;\n\n ret = tsk_identity_segments_init(result, self->nodes.num_rows, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_ibd_finder_init(&ibd_finder, self, result, min_span, max_time);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_ibd_finder_init_within(&ibd_finder, samples, num_samples);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_ibd_finder_run(&ibd_finder);\n if (ret != 0) {\n goto out;\n }\n if (!!(options & TSK_DEBUG)) {\n tsk_ibd_finder_print_state(&ibd_finder, tsk_get_debug_stream());\n }\nout:\n tsk_ibd_finder_free(&ibd_finder);\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_ibd_between(const tsk_table_collection_t *self,\n tsk_identity_segments_t *result, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, double min_span,\n double max_time, tsk_flags_t options)\n{\n int ret = 0;\n tsk_ibd_finder_t ibd_finder;\n\n ret = tsk_identity_segments_init(result, self->nodes.num_rows, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_ibd_finder_init(&ibd_finder, self, result, min_span, max_time);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_ibd_finder_init_between(\n &ibd_finder, num_sample_sets, sample_set_sizes, sample_sets);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_ibd_finder_run(&ibd_finder);\n if (ret != 0) {\n goto out;\n }\n if (!!(options & TSK_DEBUG)) {\n tsk_ibd_finder_print_state(&ibd_finder, tsk_get_debug_stream());\n }\nout:\n tsk_ibd_finder_free(&ibd_finder);\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_sort(\n tsk_table_collection_t *self, const tsk_bookmark_t *start, tsk_flags_t options)\n{\n int ret = 0;\n tsk_table_sorter_t sorter;\n\n ret = tsk_table_sorter_init(&sorter, self, options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_sorter_run(&sorter, start);\n if (ret != 0) {\n goto out;\n }\nout:\n tsk_table_sorter_free(&sorter);\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_canonicalise(tsk_table_collection_t *self, tsk_flags_t options)\n{\n int ret = 0;\n tsk_id_t k;\n tsk_id_t *nodes = NULL;\n tsk_table_sorter_t sorter;\n tsk_flags_t subset_options = options & TSK_SUBSET_KEEP_UNREFERENCED;\n\n ret = tsk_table_sorter_init(&sorter, self, 0);\n if (ret != 0) {\n goto out;\n }\n sorter.sort_mutations = tsk_table_sorter_sort_mutations;\n sorter.sort_individuals = tsk_table_sorter_sort_individuals_canonical;\n\n nodes = tsk_malloc(self->nodes.num_rows * sizeof(*nodes));\n if (nodes == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n for (k = 0; k < (tsk_id_t) self->nodes.num_rows; k++) {\n nodes[k] = k;\n }\n ret = tsk_table_collection_subset(self, nodes, self->nodes.num_rows, subset_options);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_sorter_run(&sorter, NULL);\n if (ret != 0) {\n goto out;\n }\nout:\n tsk_safe_free(nodes);\n tsk_table_sorter_free(&sorter);\n return ret;\n}\n\n/*\n * Remove any sites with duplicate positions, retaining only the *first*\n * one. Assumes the tables have been sorted, throwing an error if not.\n */\nint TSK_WARN_UNUSED\ntsk_table_collection_deduplicate_sites(\n tsk_table_collection_t *self, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_id_t ret_id;\n tsk_size_t j;\n /* Map of old site IDs to new site IDs. */\n tsk_id_t *site_id_map = NULL;\n tsk_site_table_t copy;\n tsk_site_t row, last_row;\n\n /* Early exit if there's 0 rows. We don't exit early for one row because\n * we would then skip error checking, making the semantics inconsistent. */\n if (self->sites.num_rows == 0) {\n return 0;\n }\n\n /* Must allocate the site table first for tsk_site_table_free to be safe */\n ret = tsk_site_table_copy(&self->sites, ©, 0);\n if (ret != 0) {\n goto out;\n }\n ret_id = tsk_table_collection_check_integrity(self, TSK_CHECK_SITE_ORDERING);\n if (ret_id != 0) {\n ret = (int) ret_id;\n goto out;\n }\n\n site_id_map = tsk_malloc(copy.num_rows * sizeof(*site_id_map));\n if (site_id_map == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n ret = tsk_site_table_clear(&self->sites);\n if (ret != 0) {\n goto out;\n }\n\n last_row.position = -1;\n site_id_map[0] = 0;\n for (j = 0; j < copy.num_rows; j++) {\n tsk_site_table_get_row_unsafe(©, (tsk_id_t) j, &row);\n if (row.position != last_row.position) {\n ret_id\n = tsk_site_table_add_row(&self->sites, row.position, row.ancestral_state,\n row.ancestral_state_length, row.metadata, row.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n site_id_map[j] = (tsk_id_t) self->sites.num_rows - 1;\n last_row = row;\n }\n\n if (self->sites.num_rows < copy.num_rows) {\n // Remap sites in the mutation table\n // (but only if there's been any changed sites)\n for (j = 0; j < self->mutations.num_rows; j++) {\n self->mutations.site[j] = site_id_map[self->mutations.site[j]];\n }\n }\n ret = 0;\nout:\n tsk_site_table_free(©);\n tsk_safe_free(site_id_map);\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_compute_mutation_parents(\n tsk_table_collection_t *self, tsk_flags_t options)\n{\n int ret = 0;\n tsk_mutation_table_t *mutations = &self->mutations;\n tsk_id_t *parent_backup = NULL;\n bool restore_parents = false;\n\n if (!(options & TSK_NO_CHECK_INTEGRITY)) {\n if (mutations->num_rows > 0) {\n /* We need to wipe the parent column before computing, as otherwise invalid\n * parents can cause integrity checks to fail. We take a copy to restore on\n * error */\n parent_backup = tsk_malloc(mutations->num_rows * sizeof(*parent_backup));\n if (parent_backup == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memcpy(parent_backup, mutations->parent,\n mutations->num_rows * sizeof(*parent_backup));\n /* Set the parent pointers to TSK_NULL */\n tsk_memset(mutations->parent, 0xff,\n mutations->num_rows * sizeof(*mutations->parent));\n restore_parents = true;\n }\n /* Safe to cast here as we're not counting trees */\n ret = (int) tsk_table_collection_check_integrity(self, TSK_CHECK_TREES);\n if (ret < 0) {\n goto out;\n }\n }\n\n ret = tsk_table_collection_compute_mutation_parents_to_array(\n self, self->mutations.parent);\n if (ret != 0) {\n goto out;\n }\n\nout:\n if (ret != 0 && restore_parents) {\n tsk_memcpy(mutations->parent, parent_backup,\n mutations->num_rows * sizeof(*parent_backup));\n }\n tsk_safe_free(parent_backup);\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_compute_mutation_times(\n tsk_table_collection_t *self, double *random, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_id_t num_trees;\n const tsk_id_t *restrict I = self->indexes.edge_insertion_order;\n const tsk_id_t *restrict O = self->indexes.edge_removal_order;\n const tsk_edge_table_t edges = self->edges;\n const tsk_node_table_t nodes = self->nodes;\n const tsk_site_table_t sites = self->sites;\n const tsk_mutation_table_t mutations = self->mutations;\n const tsk_id_t M = (tsk_id_t) edges.num_rows;\n tsk_id_t tj, tk;\n tsk_id_t *parent = NULL;\n double *numerator = NULL;\n double *denominator = NULL;\n tsk_id_t u;\n double left, right, parent_time;\n tsk_id_t site;\n /* Using unsigned values here avoids potentially undefined behaviour */\n tsk_size_t j, mutation, first_mutation;\n tsk_bookmark_t skip_edges = { 0, 0, self->edges.num_rows, 0, 0, 0, 0, 0 };\n\n /* The random param is for future usage */\n if (random != NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n\n /* First set the times to TSK_UNKNOWN_TIME so that check will succeed */\n for (j = 0; j < mutations.num_rows; j++) {\n mutations.time[j] = TSK_UNKNOWN_TIME;\n }\n /* TSK_CHECK_MUTATION_PARENTS isn't needed here as we're not using the parents */\n num_trees = tsk_table_collection_check_integrity(self, TSK_CHECK_TREES);\n if (num_trees < 0) {\n ret = (int) num_trees;\n goto out;\n }\n parent = tsk_malloc(nodes.num_rows * sizeof(*parent));\n numerator = tsk_malloc(nodes.num_rows * sizeof(*numerator));\n denominator = tsk_malloc(nodes.num_rows * sizeof(*denominator));\n if (parent == NULL || numerator == NULL || denominator == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(parent, 0xff, nodes.num_rows * sizeof(*parent));\n tsk_memset(numerator, 0, nodes.num_rows * sizeof(*numerator));\n tsk_memset(denominator, 0, nodes.num_rows * sizeof(*denominator));\n\n tj = 0;\n tk = 0;\n site = 0;\n mutation = 0;\n left = 0;\n while (tj < M || left < self->sequence_length) {\n while (tk < M && edges.right[O[tk]] == left) {\n parent[edges.child[O[tk]]] = TSK_NULL;\n tk++;\n }\n while (tj < M && edges.left[I[tj]] == left) {\n parent[edges.child[I[tj]]] = edges.parent[I[tj]];\n tj++;\n }\n right = self->sequence_length;\n if (tj < M) {\n right = TSK_MIN(right, edges.left[I[tj]]);\n }\n if (tk < M) {\n right = TSK_MIN(right, edges.right[O[tk]]);\n }\n\n /* Tree is now ready. We look at each site on this tree in turn */\n while (site < (tsk_id_t) sites.num_rows && sites.position[site] < right) {\n first_mutation = mutation;\n /* Count how many mutations each edge has to get our\n denominator */\n while (mutation < mutations.num_rows && mutations.site[mutation] == site) {\n denominator[mutations.node[mutation]]++;\n mutation++;\n }\n /* Go over the mutations again assigning times. As the sorting\n requirements guarantee that parents are before children, we assign\n oldest first */\n for (j = first_mutation; j < mutation; j++) {\n u = mutations.node[j];\n numerator[u]++;\n if (parent[u] == TSK_NULL) {\n /* This mutation is above a root */\n mutations.time[j] = nodes.time[u];\n } else {\n parent_time = nodes.time[parent[u]];\n mutations.time[j] = parent_time\n - (parent_time - nodes.time[u]) * numerator[u]\n / (denominator[u] + 1);\n }\n }\n /* Reset the book-keeping for the next site */\n for (j = first_mutation; j < mutation; j++) {\n u = mutations.node[j];\n numerator[u] = 0;\n denominator[u] = 0;\n }\n site++;\n }\n /* Move on to the next tree */\n left = right;\n }\n\n /* Now that mutations have times their sort order may have been invalidated, so\n * re-sort. Safe to cast the result to an int here because we're not counting\n * trees. */\n ret = (int) tsk_table_collection_check_integrity(self, TSK_CHECK_MUTATION_ORDERING);\n if (ret == TSK_ERR_UNSORTED_MUTATIONS) {\n ret = tsk_table_collection_sort(self, &skip_edges, 0);\n if (ret != 0) {\n goto out;\n }\n } else if (ret < 0) {\n goto out;\n }\n\nout:\n tsk_safe_free(parent);\n tsk_safe_free(numerator);\n tsk_safe_free(denominator);\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_delete_older(\n tsk_table_collection_t *self, double time, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_edge_t edge;\n tsk_mutation_t mutation;\n tsk_migration_t migration;\n tsk_edge_table_t edges;\n tsk_mutation_table_t mutations;\n tsk_migration_table_t migrations;\n const double *restrict node_time = self->nodes.time;\n tsk_id_t j, ret_id, parent;\n double mutation_time;\n tsk_id_t *mutation_map = NULL;\n\n memset(&edges, 0, sizeof(edges));\n memset(&mutations, 0, sizeof(mutations));\n memset(&migrations, 0, sizeof(migrations));\n\n ret = tsk_edge_table_copy(&self->edges, &edges, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_edge_table_clear(&self->edges);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < (tsk_id_t) edges.num_rows; j++) {\n tsk_edge_table_get_row_unsafe(&edges, j, &edge);\n if (node_time[edge.parent] <= time) {\n ret_id = tsk_edge_table_add_row(&self->edges, edge.left, edge.right,\n edge.parent, edge.child, edge.metadata, edge.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n }\n /* Calling x_table_free multiple times is safe, so get rid of the\n * extra edge table memory as soon as we can. */\n tsk_edge_table_free(&edges);\n\n mutation_map = tsk_malloc(self->mutations.num_rows * sizeof(*mutation_map));\n if (mutation_map == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n ret = tsk_mutation_table_copy(&self->mutations, &mutations, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_mutation_table_clear(&self->mutations);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < (tsk_id_t) mutations.num_rows; j++) {\n tsk_mutation_table_get_row_unsafe(&mutations, j, &mutation);\n mutation_time = tsk_is_unknown_time(mutation.time) ? node_time[mutation.node]\n : mutation.time;\n mutation_map[j] = TSK_NULL;\n if (mutation_time < time) {\n ret_id = tsk_mutation_table_add_row(&self->mutations, mutation.site,\n mutation.node, mutation.parent, mutation.time, mutation.derived_state,\n mutation.derived_state_length, mutation.metadata,\n mutation.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n mutation_map[j] = ret_id;\n }\n }\n tsk_mutation_table_free(&mutations);\n for (j = 0; j < (tsk_id_t) self->mutations.num_rows; j++) {\n parent = self->mutations.parent[j];\n if (parent != TSK_NULL) {\n self->mutations.parent[j] = mutation_map[parent];\n }\n }\n\n ret = tsk_migration_table_copy(&self->migrations, &migrations, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_migration_table_clear(&self->migrations);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < (tsk_id_t) migrations.num_rows; j++) {\n tsk_migration_table_get_row_unsafe(&migrations, j, &migration);\n if (migration.time < time) {\n ret_id = tsk_migration_table_add_row(&self->migrations, migration.left,\n migration.right, migration.node, migration.source, migration.dest,\n migration.time, migration.metadata, migration.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n }\n tsk_migration_table_free(&migrations);\nout:\n tsk_edge_table_free(&edges);\n tsk_mutation_table_free(&mutations);\n tsk_migration_table_free(&migrations);\n tsk_safe_free(mutation_map);\n return ret;\n}\n\nint\ntsk_table_collection_record_num_rows(\n const tsk_table_collection_t *self, tsk_bookmark_t *position)\n{\n position->individuals = self->individuals.num_rows;\n position->nodes = self->nodes.num_rows;\n position->edges = self->edges.num_rows;\n position->migrations = self->migrations.num_rows;\n position->sites = self->sites.num_rows;\n position->mutations = self->mutations.num_rows;\n position->populations = self->populations.num_rows;\n position->provenances = self->provenances.num_rows;\n return 0;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_truncate(tsk_table_collection_t *tables, tsk_bookmark_t *position)\n{\n int ret = 0;\n\n ret = tsk_table_collection_drop_index(tables, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_individual_table_truncate(&tables->individuals, position->individuals);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_node_table_truncate(&tables->nodes, position->nodes);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_edge_table_truncate(&tables->edges, position->edges);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_migration_table_truncate(&tables->migrations, position->migrations);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_site_table_truncate(&tables->sites, position->sites);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_mutation_table_truncate(&tables->mutations, position->mutations);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_population_table_truncate(&tables->populations, position->populations);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_provenance_table_truncate(&tables->provenances, position->provenances);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_clear(tsk_table_collection_t *self, tsk_flags_t options)\n{\n int ret = 0;\n bool clear_provenance = !!(options & TSK_CLEAR_PROVENANCE);\n bool clear_metadata_schemas = !!(options & TSK_CLEAR_METADATA_SCHEMAS);\n bool clear_ts_metadata = !!(options & TSK_CLEAR_TS_METADATA_AND_SCHEMA);\n tsk_bookmark_t rows_to_retain\n = { .provenances = clear_provenance ? 0 : self->provenances.num_rows };\n\n ret = tsk_table_collection_truncate(self, &rows_to_retain);\n if (ret != 0) {\n goto out;\n }\n\n if (clear_metadata_schemas) {\n ret = tsk_individual_table_set_metadata_schema(&self->individuals, \"\", 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_node_table_set_metadata_schema(&self->nodes, \"\", 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_edge_table_set_metadata_schema(&self->edges, \"\", 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_migration_table_set_metadata_schema(&self->migrations, \"\", 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_site_table_set_metadata_schema(&self->sites, \"\", 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_mutation_table_set_metadata_schema(&self->mutations, \"\", 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_population_table_set_metadata_schema(&self->populations, \"\", 0);\n if (ret != 0) {\n goto out;\n }\n }\n\n if (clear_ts_metadata) {\n ret = tsk_table_collection_set_metadata(self, \"\", 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_set_metadata_schema(self, \"\", 0);\n if (ret != 0) {\n goto out;\n }\n }\n\nout:\n return ret;\n}\n\nstatic int\ntsk_table_collection_add_and_remap_node(tsk_table_collection_t *self,\n const tsk_table_collection_t *other, tsk_id_t node_id, tsk_id_t *individual_map,\n tsk_id_t *population_map, tsk_id_t *node_map, bool add_populations)\n{\n int ret = 0;\n tsk_id_t ret_id, new_ind, new_pop;\n tsk_node_t node;\n tsk_individual_t ind;\n tsk_population_t pop;\n\n ret = tsk_node_table_get_row(&other->nodes, node_id, &node);\n if (ret < 0) {\n goto out;\n }\n new_ind = TSK_NULL;\n if (node.individual != TSK_NULL) {\n if (individual_map[node.individual] == TSK_NULL) {\n ret = tsk_individual_table_get_row(\n &other->individuals, node.individual, &ind);\n if (ret < 0) {\n goto out;\n }\n ret_id = tsk_individual_table_add_row(&self->individuals, ind.flags,\n ind.location, ind.location_length, ind.parents, ind.parents_length,\n ind.metadata, ind.metadata_length);\n if (ret < 0) {\n ret = (int) ret_id;\n goto out;\n }\n individual_map[node.individual] = ret_id;\n }\n new_ind = individual_map[node.individual];\n }\n new_pop = TSK_NULL;\n if (node.population != TSK_NULL) {\n // keep same pops if add_populations is False\n if (!add_populations) {\n population_map[node.population] = node.population;\n }\n if (population_map[node.population] == TSK_NULL) {\n ret = tsk_population_table_get_row(\n &other->populations, node.population, &pop);\n if (ret < 0) {\n goto out;\n }\n ret_id = tsk_population_table_add_row(\n &self->populations, pop.metadata, pop.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n population_map[node.population] = ret_id;\n }\n new_pop = population_map[node.population];\n }\n ret_id = tsk_node_table_add_row(&self->nodes, node.flags, node.time, new_pop,\n new_ind, node.metadata, node.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n node_map[node.id] = ret_id;\n\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_subset(tsk_table_collection_t *self, const tsk_id_t *nodes,\n tsk_size_t num_nodes, tsk_flags_t options)\n{\n int ret = 0;\n tsk_id_t ret_id, j, k, parent_ind, new_parent, new_child, new_node, site_id;\n tsk_size_t num_parents;\n tsk_individual_t ind;\n tsk_edge_t edge;\n tsk_id_t *node_map = NULL;\n tsk_id_t *individual_map = NULL;\n tsk_id_t *population_map = NULL;\n tsk_id_t *site_map = NULL;\n tsk_id_t *mutation_map = NULL;\n tsk_table_collection_t tables;\n tsk_population_t pop;\n tsk_site_t site;\n tsk_mutation_t mut;\n bool keep_unreferenced = !!(options & TSK_SUBSET_KEEP_UNREFERENCED);\n bool no_change_populations = !!(options & TSK_SUBSET_NO_CHANGE_POPULATIONS);\n\n ret = tsk_table_collection_copy(self, &tables, 0);\n if (ret != 0) {\n goto out;\n }\n /* Not calling TSK_CHECK_TREES so casting to int is safe */\n ret = (int) tsk_table_collection_check_integrity(self, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_clear(self, 0);\n if (ret != 0) {\n goto out;\n }\n\n node_map = tsk_malloc(tables.nodes.num_rows * sizeof(*node_map));\n individual_map = tsk_malloc(tables.individuals.num_rows * sizeof(*individual_map));\n population_map = tsk_malloc(tables.populations.num_rows * sizeof(*population_map));\n site_map = tsk_malloc(tables.sites.num_rows * sizeof(*site_map));\n mutation_map = tsk_malloc(tables.mutations.num_rows * sizeof(*mutation_map));\n if (node_map == NULL || individual_map == NULL || population_map == NULL\n || site_map == NULL || mutation_map == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(node_map, 0xff, tables.nodes.num_rows * sizeof(*node_map));\n tsk_memset(\n individual_map, 0xff, tables.individuals.num_rows * sizeof(*individual_map));\n tsk_memset(\n population_map, 0xff, tables.populations.num_rows * sizeof(*population_map));\n tsk_memset(site_map, 0xff, tables.sites.num_rows * sizeof(*site_map));\n tsk_memset(mutation_map, 0xff, tables.mutations.num_rows * sizeof(*mutation_map));\n\n if (no_change_populations) {\n ret = tsk_population_table_copy(\n &tables.populations, &self->populations, TSK_NO_INIT);\n if (ret < 0) {\n goto out;\n }\n for (k = 0; k < (tsk_id_t) tables.populations.num_rows; k++) {\n population_map[k] = k;\n }\n }\n\n // First do individuals so they stay in the same order.\n // So we can remap individual parents and not rely on sortedness,\n // we first check who to keep; then build the individual map, and\n // finally populate the tables.\n if (keep_unreferenced) {\n for (k = 0; k < (tsk_id_t) tables.individuals.num_rows; k++) {\n // put a non-NULL value here; fill in the actual order next\n individual_map[k] = 0;\n }\n } else {\n for (k = 0; k < (tsk_id_t) num_nodes; k++) {\n if (nodes[k] < 0 || nodes[k] >= (tsk_id_t) tables.nodes.num_rows) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n j = tables.nodes.individual[nodes[k]];\n if (j != TSK_NULL) {\n individual_map[j] = 0;\n }\n }\n }\n j = 0;\n for (k = 0; k < (tsk_id_t) tables.individuals.num_rows; k++) {\n if (individual_map[k] != TSK_NULL) {\n individual_map[k] = j;\n j++;\n }\n }\n for (k = 0; k < (tsk_id_t) tables.individuals.num_rows; k++) {\n if (individual_map[k] != TSK_NULL) {\n tsk_individual_table_get_row_unsafe(&tables.individuals, k, &ind);\n num_parents = 0;\n for (j = 0; j < (tsk_id_t) ind.parents_length; j++) {\n parent_ind = ind.parents[j];\n new_parent = parent_ind;\n if (parent_ind != TSK_NULL) {\n new_parent = individual_map[parent_ind];\n }\n if ((parent_ind == TSK_NULL) || (new_parent != TSK_NULL)) {\n /* Beware: this modifies the parents column of tables.individuals\n * in-place! But it's OK as we don't use it again. */\n ind.parents[num_parents] = new_parent;\n num_parents++;\n }\n }\n ret_id = tsk_individual_table_add_row(&self->individuals, ind.flags,\n ind.location, ind.location_length, ind.parents, num_parents,\n ind.metadata, ind.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n tsk_bug_assert(individual_map[k] == ret_id);\n }\n }\n\n // Nodes and populations\n for (k = 0; k < (tsk_id_t) num_nodes; k++) {\n ret = tsk_table_collection_add_and_remap_node(\n self, &tables, nodes[k], individual_map, population_map, node_map, true);\n if (ret < 0) {\n goto out;\n }\n }\n\n /* TODO: Subset the migrations table. We would need to make sure\n * that we don't remove populations that are referenced, so it would\n * need to be done before the next code block. */\n if (tables.migrations.num_rows != 0) {\n ret = tsk_trace_error(TSK_ERR_MIGRATIONS_NOT_SUPPORTED);\n goto out;\n }\n\n if (keep_unreferenced) {\n // Keep unused populations\n for (k = 0; k < (tsk_id_t) tables.populations.num_rows; k++) {\n if (population_map[k] == TSK_NULL) {\n tsk_population_table_get_row_unsafe(&tables.populations, k, &pop);\n ret_id = tsk_population_table_add_row(\n &self->populations, pop.metadata, pop.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n }\n }\n\n // Edges\n for (k = 0; k < (tsk_id_t) tables.edges.num_rows; k++) {\n tsk_edge_table_get_row_unsafe(&tables.edges, k, &edge);\n new_parent = node_map[edge.parent];\n new_child = node_map[edge.child];\n if ((new_parent != TSK_NULL) && (new_child != TSK_NULL)) {\n ret_id = tsk_edge_table_add_row(&self->edges, edge.left, edge.right,\n new_parent, new_child, edge.metadata, edge.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n }\n\n // Mutations and sites\n // Make a first pass through to build the mutation_map so that\n // mutation parent can be remapped even if the table is not in order.\n j = 0;\n for (k = 0; k < (tsk_id_t) tables.mutations.num_rows; k++) {\n if (node_map[tables.mutations.node[k]] != TSK_NULL) {\n mutation_map[k] = j;\n j++;\n site_id = tables.mutations.site[k];\n if (site_map[site_id] == TSK_NULL) {\n // Insert a temporary non-NULL value\n site_map[site_id] = 1;\n }\n }\n }\n // Keep retained sites in their original order\n j = 0;\n for (k = 0; k < (tsk_id_t) tables.sites.num_rows; k++) {\n if (keep_unreferenced || site_map[k] != TSK_NULL) {\n tsk_site_table_get_row_unsafe(&tables.sites, k, &site);\n ret_id = tsk_site_table_add_row(&self->sites, site.position,\n site.ancestral_state, site.ancestral_state_length, site.metadata,\n site.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n site_map[k] = j;\n j++;\n }\n }\n for (k = 0; k < (tsk_id_t) tables.mutations.num_rows; k++) {\n tsk_mutation_table_get_row_unsafe(&tables.mutations, k, &mut);\n new_node = node_map[mut.node];\n if (new_node != TSK_NULL) {\n new_parent = TSK_NULL;\n if (mut.parent != TSK_NULL) {\n new_parent = mutation_map[mut.parent];\n }\n ret_id = tsk_mutation_table_add_row(&self->mutations, site_map[mut.site],\n new_node, new_parent, mut.time, mut.derived_state,\n mut.derived_state_length, mut.metadata, mut.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n tsk_bug_assert(mutation_map[mut.id] == ret_id);\n }\n if (ret < 0) {\n goto out;\n }\n }\n\n ret = 0;\nout:\n tsk_safe_free(node_map);\n tsk_safe_free(individual_map);\n tsk_safe_free(population_map);\n tsk_safe_free(site_map);\n tsk_safe_free(mutation_map);\n tsk_table_collection_free(&tables);\n return ret;\n}\n\nstatic int\ntsk_check_subset_equality(tsk_table_collection_t *self,\n const tsk_table_collection_t *other, const tsk_id_t *other_node_mapping,\n tsk_size_t num_shared_nodes)\n{\n int ret = 0;\n tsk_id_t k, i;\n tsk_id_t *self_nodes = NULL;\n tsk_id_t *other_nodes = NULL;\n tsk_table_collection_t self_copy;\n tsk_table_collection_t other_copy;\n\n tsk_memset(&self_copy, 0, sizeof(self_copy));\n tsk_memset(&other_copy, 0, sizeof(other_copy));\n self_nodes = tsk_malloc(num_shared_nodes * sizeof(*self_nodes));\n other_nodes = tsk_malloc(num_shared_nodes * sizeof(*other_nodes));\n if (self_nodes == NULL || other_nodes == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n i = 0;\n for (k = 0; k < (tsk_id_t) other->nodes.num_rows; k++) {\n if (other_node_mapping[k] != TSK_NULL) {\n self_nodes[i] = other_node_mapping[k];\n other_nodes[i] = k;\n i++;\n }\n }\n\n ret = tsk_table_collection_copy(self, &self_copy, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_copy(other, &other_copy, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_subset(&self_copy, self_nodes, num_shared_nodes, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_subset(&other_copy, other_nodes, num_shared_nodes, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_canonicalise(&self_copy, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_canonicalise(&other_copy, 0);\n if (ret != 0) {\n goto out;\n }\n if (!tsk_table_collection_equals(&self_copy, &other_copy,\n TSK_CMP_IGNORE_TS_METADATA | TSK_CMP_IGNORE_PROVENANCE\n | TSK_CMP_IGNORE_REFERENCE_SEQUENCE)) {\n ret = tsk_trace_error(TSK_ERR_UNION_DIFF_HISTORIES);\n goto out;\n }\n\nout:\n tsk_table_collection_free(&self_copy);\n tsk_table_collection_free(&other_copy);\n tsk_safe_free(other_nodes);\n tsk_safe_free(self_nodes);\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_table_collection_union(tsk_table_collection_t *self,\n const tsk_table_collection_t *other, const tsk_id_t *other_node_mapping,\n tsk_flags_t options)\n{\n int ret = 0;\n tsk_id_t ret_id, k, i, new_parent, new_child;\n tsk_size_t num_shared_nodes = 0;\n tsk_size_t num_individuals_self = self->individuals.num_rows;\n tsk_edge_t edge;\n tsk_mutation_t mut;\n tsk_site_t site;\n tsk_id_t *node_map = NULL;\n tsk_id_t *individual_map = NULL;\n tsk_id_t *population_map = NULL;\n tsk_id_t *site_map = NULL;\n bool add_populations = !(options & TSK_UNION_NO_ADD_POP);\n bool check_shared_portion = !(options & TSK_UNION_NO_CHECK_SHARED);\n bool all_edges = !!(options & TSK_UNION_ALL_EDGES);\n bool all_mutations = !!(options & TSK_UNION_ALL_MUTATIONS);\n\n /* Not calling TSK_CHECK_TREES so casting to int is safe */\n ret = (int) tsk_table_collection_check_integrity(self, 0);\n if (ret != 0) {\n goto out;\n }\n ret = (int) tsk_table_collection_check_integrity(other, 0);\n if (ret != 0) {\n goto out;\n }\n for (k = 0; k < (tsk_id_t) other->nodes.num_rows; k++) {\n if (other_node_mapping[k] >= (tsk_id_t) self->nodes.num_rows\n || other_node_mapping[k] < TSK_NULL) {\n ret = tsk_trace_error(TSK_ERR_UNION_BAD_MAP);\n goto out;\n }\n if (other_node_mapping[k] != TSK_NULL) {\n num_shared_nodes++;\n }\n }\n\n if (check_shared_portion) {\n ret = tsk_check_subset_equality(\n self, other, other_node_mapping, num_shared_nodes);\n if (ret != 0) {\n goto out;\n }\n }\n\n // Maps relating the IDs in other to the new IDs in self.\n node_map = tsk_malloc(other->nodes.num_rows * sizeof(*node_map));\n individual_map = tsk_malloc(other->individuals.num_rows * sizeof(*individual_map));\n population_map = tsk_malloc(other->populations.num_rows * sizeof(*population_map));\n site_map = tsk_malloc(other->sites.num_rows * sizeof(*site_map));\n if (node_map == NULL || individual_map == NULL || population_map == NULL\n || site_map == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(node_map, 0xff, other->nodes.num_rows * sizeof(*node_map));\n tsk_memset(\n individual_map, 0xff, other->individuals.num_rows * sizeof(*individual_map));\n tsk_memset(\n population_map, 0xff, other->populations.num_rows * sizeof(*population_map));\n tsk_memset(site_map, 0xff, other->sites.num_rows * sizeof(*site_map));\n\n /* We have to map the individuals who are linked to nodes in the intersection first\n as otherwise an individual linked to one node in the intersection and one in\n `other` would be duplicated. We assume that the individual in `self` takes\n priority.\n */\n for (k = 0; k < (tsk_id_t) other->nodes.num_rows; k++) {\n if (other_node_mapping[k] != TSK_NULL\n && other->nodes.individual[k] != TSK_NULL) {\n individual_map[other->nodes.individual[k]]\n = self->nodes.individual[other_node_mapping[k]];\n }\n }\n // nodes, individuals, populations\n for (k = 0; k < (tsk_id_t) other->nodes.num_rows; k++) {\n if (other_node_mapping[k] != TSK_NULL) {\n node_map[k] = other_node_mapping[k];\n } else {\n ret = tsk_table_collection_add_and_remap_node(self, other, k, individual_map,\n population_map, node_map, add_populations);\n if (ret < 0) {\n goto out;\n }\n }\n }\n\n /* Now we know the full individual map we can remap the parents of the new\n * individuals*/\n for (k = (tsk_id_t) self->individuals.parents_offset[num_individuals_self];\n k < (tsk_id_t) self->individuals.parents_length; k++) {\n if (self->individuals.parents[k] != TSK_NULL) {\n self->individuals.parents[k] = individual_map[self->individuals.parents[k]];\n }\n }\n\n // edges\n for (k = 0; k < (tsk_id_t) other->edges.num_rows; k++) {\n tsk_edge_table_get_row_unsafe(&other->edges, k, &edge);\n if (all_edges || (other_node_mapping[edge.parent] == TSK_NULL)\n || (other_node_mapping[edge.child] == TSK_NULL)) {\n new_parent = node_map[edge.parent];\n new_child = node_map[edge.child];\n ret_id = tsk_edge_table_add_row(&self->edges, edge.left, edge.right,\n new_parent, new_child, edge.metadata, edge.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n }\n\n // sites\n // first do the \"disjoint\" (all_mutations) case, where we just add all sites;\n // otherwise we want to just add sites for new mutations\n if (all_mutations) {\n for (k = 0; k < (tsk_id_t) other->sites.num_rows; k++) {\n tsk_site_table_get_row_unsafe(&other->sites, k, &site);\n ret_id = tsk_site_table_add_row(&self->sites, site.position,\n site.ancestral_state, site.ancestral_state_length, site.metadata,\n site.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n site_map[site.id] = ret_id;\n }\n }\n\n // mutations (and maybe sites)\n i = 0;\n for (k = 0; k < (tsk_id_t) other->sites.num_rows; k++) {\n tsk_site_table_get_row_unsafe(&other->sites, k, &site);\n while ((i < (tsk_id_t) other->mutations.num_rows)\n && (other->mutations.site[i] == site.id)) {\n tsk_mutation_table_get_row_unsafe(&other->mutations, i, &mut);\n if (all_mutations || (other_node_mapping[mut.node] == TSK_NULL)) {\n if (site_map[site.id] == TSK_NULL) {\n ret_id = tsk_site_table_add_row(&self->sites, site.position,\n site.ancestral_state, site.ancestral_state_length, site.metadata,\n site.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n site_map[site.id] = ret_id;\n }\n // the parents will be recomputed later\n new_parent = TSK_NULL;\n ret_id = tsk_mutation_table_add_row(&self->mutations, site_map[site.id],\n node_map[mut.node], new_parent, mut.time, mut.derived_state,\n mut.derived_state_length, mut.metadata, mut.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n i++;\n }\n }\n\n /* TODO: Union of the Migrations Table. The only hindrance to performing the\n * union operation on Migrations Tables is that tsk_table_collection_sort\n * does not sort migrations by time, and instead throws an error. */\n if (self->migrations.num_rows != 0 || other->migrations.num_rows != 0) {\n ret = tsk_trace_error(TSK_ERR_MIGRATIONS_NOT_SUPPORTED);\n goto out;\n }\n\n // sorting, deduplicating, and computing parents\n ret = tsk_table_collection_sort(self, 0, 0);\n if (ret < 0) {\n goto out;\n }\n\n ret = tsk_table_collection_deduplicate_sites(self, 0);\n if (ret < 0) {\n goto out;\n }\n\n // need to sort again since after deduplicating sites, mutations\n // may not be sorted by time within sites\n ret = tsk_table_collection_sort(self, 0, 0);\n if (ret < 0) {\n goto out;\n }\n\n ret = tsk_table_collection_build_index(self, 0);\n if (ret < 0) {\n goto out;\n }\n\n ret = tsk_table_collection_compute_mutation_parents(self, 0);\n if (ret < 0) {\n goto out;\n }\n\nout:\n tsk_safe_free(node_map);\n tsk_safe_free(individual_map);\n tsk_safe_free(population_map);\n tsk_safe_free(site_map);\n return ret;\n}\n\nstatic int\ncmp_edge_cl(const void *a, const void *b)\n{\n const tsk_edge_t *ia = (const tsk_edge_t *) a;\n const tsk_edge_t *ib = (const tsk_edge_t *) b;\n int ret = (ia->parent > ib->parent) - (ia->parent < ib->parent);\n if (ret == 0) {\n ret = (ia->child > ib->child) - (ia->child < ib->child);\n if (ret == 0) {\n ret = (ia->left > ib->left) - (ia->left < ib->left);\n }\n }\n return ret;\n}\n\n/* Squash the edges in the specified array in place. The output edges will\n * be sorted by (child_id, left).\n */\n\nint TSK_WARN_UNUSED\ntsk_squash_edges(tsk_edge_t *edges, tsk_size_t num_edges, tsk_size_t *num_output_edges)\n{\n int ret = 0;\n tsk_size_t j, k, l;\n\n if (num_edges < 2) {\n *num_output_edges = num_edges;\n return ret;\n }\n\n qsort(edges, (size_t) num_edges, sizeof(tsk_edge_t), cmp_edge_cl);\n j = 0;\n l = 0;\n for (k = 1; k < num_edges; k++) {\n if (edges[k - 1].metadata_length > 0) {\n ret = tsk_trace_error(TSK_ERR_CANT_PROCESS_EDGES_WITH_METADATA);\n goto out;\n }\n\n /* Check for overlapping edges. */\n if (edges[k - 1].parent == edges[k].parent\n && edges[k - 1].child == edges[k].child\n && edges[k - 1].right > edges[k].left) {\n ret = tsk_trace_error(TSK_ERR_BAD_EDGES_CONTRADICTORY_CHILDREN);\n goto out;\n }\n\n /* Add squashed edge. */\n if (edges[k - 1].parent != edges[k].parent || edges[k - 1].right != edges[k].left\n || edges[j].child != edges[k].child) {\n\n edges[l].left = edges[j].left;\n edges[l].right = edges[k - 1].right;\n edges[l].parent = edges[j].parent;\n edges[l].child = edges[j].child;\n\n j = k;\n l++;\n }\n }\n edges[l].left = edges[j].left;\n edges[l].right = edges[k - 1].right;\n edges[l].parent = edges[j].parent;\n edges[l].child = edges[j].child;\n\n *num_output_edges = (tsk_size_t) l + 1;\n\nout:\n return ret;\n}\n"
},
{
"path": "c/tskit/tables.h",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2024 Tskit Developers\n * Copyright (c) 2017-2018 University of Oxford\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n/**\n * @file tables.h\n * @brief Tskit Tables API.\n */\n#ifndef TSK_TABLES_H\n#define TSK_TABLES_H\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#include \n#include \n#include \n\n#include \n\n#include \n\n/****************************************************************************/\n/* Definitions for the basic objects */\n/****************************************************************************/\n\n/**\n@brief A single individual defined by a row in the individual table.\n\n@rst\nSee the :ref:`data model ` section for the definition of\nan individual and its properties.\n@endrst\n*/\ntypedef struct {\n /** @brief Non-negative ID value corresponding to table row. */\n tsk_id_t id;\n /** @brief Bitwise flags. */\n tsk_flags_t flags;\n /** @brief Spatial location. The number of dimensions is defined by\n * ``location_length``. */\n const double *location;\n /** @brief Number of spatial dimensions. */\n tsk_size_t location_length;\n /** @brief IDs of the parents. The number of parents given by ``parents_length``*/\n tsk_id_t *parents;\n /** @brief Number of parents. */\n tsk_size_t parents_length;\n /** @brief Metadata. */\n const char *metadata;\n /** @brief Size of the metadata in bytes. */\n tsk_size_t metadata_length;\n /** @brief An array of the nodes associated with this individual */\n const tsk_id_t *nodes;\n /** @brief The number of nodes associated with this individual*/\n tsk_size_t nodes_length;\n} tsk_individual_t;\n\n/**\n@brief A single node defined by a row in the node table.\n\n@rst\nSee the :ref:`data model ` section for the definition of\na node and its properties.\n@endrst\n*/\ntypedef struct {\n /** @brief Non-negative ID value corresponding to table row. */\n tsk_id_t id;\n /** @brief Bitwise flags. */\n tsk_flags_t flags;\n /** @brief Time. */\n double time;\n /** @brief Population ID. */\n tsk_id_t population;\n /** @brief Individual ID. */\n tsk_id_t individual;\n /** @brief Metadata. */\n const char *metadata;\n /** @brief Size of the metadata in bytes. */\n tsk_size_t metadata_length;\n} tsk_node_t;\n\n/**\n@brief A single edge defined by a row in the edge table.\n\n@rst\nSee the :ref:`data model ` section for the definition of\nan edge and its properties.\n@endrst\n*/\ntypedef struct {\n /** @brief Non-negative ID value corresponding to table row. */\n tsk_id_t id;\n /** @brief Parent node ID. */\n tsk_id_t parent;\n /** @brief Child node ID. */\n tsk_id_t child;\n /** @brief Left coordinate. */\n double left;\n /** @brief Right coordinate. */\n double right;\n /** @brief Metadata. */\n const char *metadata;\n /** @brief Size of the metadata in bytes. */\n tsk_size_t metadata_length;\n} tsk_edge_t;\n\n/**\n@brief A single mutation defined by a row in the mutation table.\n\n@rst\nSee the :ref:`data model ` section for the definition of\na mutation and its properties.\n@endrst\n*/\ntypedef struct {\n /** @brief Non-negative ID value corresponding to table row. */\n tsk_id_t id;\n /** @brief Site ID. */\n tsk_id_t site;\n /** @brief Node ID. */\n tsk_id_t node;\n /** @brief Parent mutation ID. */\n tsk_id_t parent;\n /** @brief Mutation time. */\n double time;\n /** @brief Derived state. */\n const char *derived_state;\n /** @brief Size of the derived state in bytes. */\n tsk_size_t derived_state_length;\n /** @brief Metadata. */\n const char *metadata;\n /** @brief Size of the metadata in bytes. */\n tsk_size_t metadata_length;\n /** @brief The ID of the edge that this mutation lies on, or TSK_NULL\n if there is no corresponding edge.*/\n tsk_id_t edge;\n /** @brief Inherited state. */\n const char *inherited_state;\n /** @brief Size of the inherited state in bytes. */\n tsk_size_t inherited_state_length;\n} tsk_mutation_t;\n\n/**\n@brief A single site defined by a row in the site table.\n\n@rst\nSee the :ref:`data model ` section for the definition of\na site and its properties.\n@endrst\n*/\ntypedef struct {\n /** @brief Non-negative ID value corresponding to table row. */\n tsk_id_t id;\n /** @brief Position coordinate. */\n double position;\n /** @brief Ancestral state. */\n const char *ancestral_state;\n /** @brief Ancestral state length in bytes. */\n tsk_size_t ancestral_state_length;\n /** @brief Metadata. */\n const char *metadata;\n /** @brief Metadata length in bytes. */\n tsk_size_t metadata_length;\n /** @brief An array of this site's mutations */\n const tsk_mutation_t *mutations;\n /** @brief The number of mutations at this site */\n tsk_size_t mutations_length;\n} tsk_site_t;\n\n/**\n@brief A single migration defined by a row in the migration table.\n\n@rst\nSee the :ref:`data model ` section for the definition of\na migration and its properties.\n@endrst\n*/\ntypedef struct {\n /** @brief Non-negative ID value corresponding to table row. */\n tsk_id_t id;\n /** @brief Source population ID. */\n tsk_id_t source;\n /** @brief Destination population ID. */\n tsk_id_t dest;\n /** @brief Node ID. */\n tsk_id_t node;\n /** @brief Left coordinate. */\n double left;\n /** @brief Right coordinate. */\n double right;\n /** @brief Time. */\n double time;\n /** @brief Metadata. */\n const char *metadata;\n /** @brief Size of the metadata in bytes. */\n tsk_size_t metadata_length;\n\n} tsk_migration_t;\n\n/**\n@brief A single population defined by a row in the population table.\n\n@rst\nSee the :ref:`data model ` section for the definition of\na population and its properties.\n@endrst\n*/\ntypedef struct {\n /** @brief Non-negative ID value corresponding to table row. */\n tsk_id_t id;\n /** @brief Metadata. */\n const char *metadata;\n /** @brief Metadata length in bytes. */\n tsk_size_t metadata_length;\n} tsk_population_t;\n\n/**\n@brief A single provenance defined by a row in the provenance table.\n\n@rst\nSee the :ref:`data model ` section for the definition of\na provenance object and its properties. See the :ref:`sec_provenance` section\nfor more information on how provenance records should be structured.\n@endrst\n*/\ntypedef struct {\n /** @brief Non-negative ID value corresponding to table row. */\n tsk_id_t id;\n /** @brief The timestamp. */\n const char *timestamp;\n /** @brief The timestamp length in bytes. */\n tsk_size_t timestamp_length;\n /** @brief The record. */\n const char *record;\n /** @brief The record length in bytes. */\n tsk_size_t record_length;\n} tsk_provenance_t;\n\n/****************************************************************************/\n/* Table definitions */\n/****************************************************************************/\n\n/**\n@brief The individual table.\n\n@rst\nSee the individual :ref:`table definition ` for\ndetails of the columns in this table.\n@endrst\n*/\ntypedef struct {\n /** @brief The number of rows in this table. */\n tsk_size_t num_rows;\n tsk_size_t max_rows;\n tsk_size_t max_rows_increment;\n /** @brief The total length of the location column. */\n tsk_size_t location_length;\n tsk_size_t max_location_length;\n tsk_size_t max_location_length_increment;\n /** @brief The total length of the parent column. */\n tsk_size_t parents_length;\n tsk_size_t max_parents_length;\n tsk_size_t max_parents_length_increment;\n /** @brief The total length of the metadata column. */\n tsk_size_t metadata_length;\n tsk_size_t max_metadata_length;\n tsk_size_t max_metadata_length_increment;\n tsk_size_t metadata_schema_length;\n /** @brief The flags column. */\n tsk_flags_t *flags;\n /** @brief The location column. */\n double *location;\n /** @brief The location_offset column. */\n tsk_size_t *location_offset;\n /** @brief The parents column. */\n tsk_id_t *parents;\n /** @brief The parents_offset column. */\n tsk_size_t *parents_offset;\n /** @brief The metadata column. */\n char *metadata;\n /** @brief The metadata_offset column. */\n tsk_size_t *metadata_offset;\n /** @brief The metadata schema */\n char *metadata_schema;\n} tsk_individual_table_t;\n\n/**\n@brief The node table.\n\n@rst\nSee the node :ref:`table definition ` for\ndetails of the columns in this table.\n@endrst\n*/\ntypedef struct {\n /** @brief The number of rows in this table. */\n tsk_size_t num_rows;\n tsk_size_t max_rows;\n tsk_size_t max_rows_increment;\n /** @brief The total length of the metadata column. */\n tsk_size_t metadata_length;\n tsk_size_t max_metadata_length;\n tsk_size_t max_metadata_length_increment;\n tsk_size_t metadata_schema_length;\n /** @brief The flags column. */\n tsk_flags_t *flags;\n /** @brief The time column. */\n double *time;\n /** @brief The population column. */\n tsk_id_t *population;\n /** @brief The individual column. */\n tsk_id_t *individual;\n /** @brief The metadata column. */\n char *metadata;\n /** @brief The metadata_offset column. */\n tsk_size_t *metadata_offset;\n /** @brief The metadata schema */\n char *metadata_schema;\n} tsk_node_table_t;\n\n/**\n@brief The edge table.\n\n@rst\nSee the edge :ref:`table definition ` for\ndetails of the columns in this table.\n@endrst\n*/\ntypedef struct {\n /** @brief The number of rows in this table. */\n tsk_size_t num_rows;\n tsk_size_t max_rows;\n tsk_size_t max_rows_increment;\n /** @brief The total length of the metadata column. */\n tsk_size_t metadata_length;\n tsk_size_t max_metadata_length;\n tsk_size_t max_metadata_length_increment;\n tsk_size_t metadata_schema_length;\n /** @brief The left column. */\n double *left;\n /** @brief The right column. */\n double *right;\n /** @brief The parent column. */\n tsk_id_t *parent;\n /** @brief The child column. */\n tsk_id_t *child;\n /** @brief The metadata column. */\n char *metadata;\n /** @brief The metadata_offset column. */\n tsk_size_t *metadata_offset;\n /** @brief The metadata schema */\n char *metadata_schema;\n /** @brief Flags for this table */\n tsk_flags_t options;\n} tsk_edge_table_t;\n\n/**\n@brief The migration table.\n\n@rst\nSee the migration :ref:`table definition ` for\ndetails of the columns in this table.\n@endrst\n*/\ntypedef struct {\n /** @brief The number of rows in this table. */\n tsk_size_t num_rows;\n tsk_size_t max_rows;\n tsk_size_t max_rows_increment;\n /** @brief The total length of the metadata column. */\n tsk_size_t metadata_length;\n tsk_size_t max_metadata_length;\n tsk_size_t max_metadata_length_increment;\n tsk_size_t metadata_schema_length;\n /** @brief The source column. */\n tsk_id_t *source;\n /** @brief The dest column. */\n tsk_id_t *dest;\n /** @brief The node column. */\n tsk_id_t *node;\n /** @brief The left column. */\n double *left;\n /** @brief The right column. */\n double *right;\n /** @brief The time column. */\n double *time;\n /** @brief The metadata column. */\n char *metadata;\n /** @brief The metadata_offset column. */\n tsk_size_t *metadata_offset;\n /** @brief The metadata schema */\n char *metadata_schema;\n} tsk_migration_table_t;\n\n/**\n@brief The site table.\n\n@rst\nSee the site :ref:`table definition ` for\ndetails of the columns in this table.\n@endrst\n*/\ntypedef struct {\n /** @brief The number of rows in this table. */\n tsk_size_t num_rows;\n tsk_size_t max_rows;\n tsk_size_t max_rows_increment;\n tsk_size_t ancestral_state_length;\n tsk_size_t max_ancestral_state_length;\n tsk_size_t max_ancestral_state_length_increment;\n /** @brief The total length of the metadata column. */\n tsk_size_t metadata_length;\n tsk_size_t max_metadata_length;\n tsk_size_t max_metadata_length_increment;\n tsk_size_t metadata_schema_length;\n /** @brief The position column. */\n double *position;\n /** @brief The ancestral_state column. */\n char *ancestral_state;\n /** @brief The ancestral_state_offset column. */\n tsk_size_t *ancestral_state_offset;\n /** @brief The metadata column. */\n char *metadata;\n /** @brief The metadata_offset column. */\n tsk_size_t *metadata_offset;\n /** @brief The metadata schema */\n char *metadata_schema;\n} tsk_site_table_t;\n\n/**\n@brief The mutation table.\n\n@rst\nSee the mutation :ref:`table definition ` for\ndetails of the columns in this table.\n@endrst\n*/\ntypedef struct {\n /** @brief The number of rows in this table. */\n tsk_size_t num_rows;\n tsk_size_t max_rows;\n tsk_size_t max_rows_increment;\n tsk_size_t derived_state_length;\n tsk_size_t max_derived_state_length;\n tsk_size_t max_derived_state_length_increment;\n /** @brief The total length of the metadata column. */\n tsk_size_t metadata_length;\n tsk_size_t max_metadata_length;\n tsk_size_t max_metadata_length_increment;\n tsk_size_t metadata_schema_length;\n /** @brief The node column. */\n tsk_id_t *node;\n /** @brief The site column. */\n tsk_id_t *site;\n /** @brief The parent column. */\n tsk_id_t *parent;\n /** @brief The time column. */\n double *time;\n /** @brief The derived_state column. */\n char *derived_state;\n /** @brief The derived_state_offset column. */\n tsk_size_t *derived_state_offset;\n /** @brief The metadata column. */\n char *metadata;\n /** @brief The metadata_offset column. */\n tsk_size_t *metadata_offset;\n /** @brief The metadata schema */\n char *metadata_schema;\n} tsk_mutation_table_t;\n\n/**\n@brief The population table.\n\n@rst\nSee the population :ref:`table definition ` for\ndetails of the columns in this table.\n@endrst\n*/\ntypedef struct {\n /** @brief The number of rows in this table. */\n tsk_size_t num_rows;\n tsk_size_t max_rows;\n tsk_size_t max_rows_increment;\n /** @brief The total length of the metadata column. */\n tsk_size_t metadata_length;\n tsk_size_t max_metadata_length;\n tsk_size_t max_metadata_length_increment;\n tsk_size_t metadata_schema_length;\n /** @brief The metadata column. */\n char *metadata;\n /** @brief The metadata_offset column. */\n tsk_size_t *metadata_offset;\n /** @brief The metadata schema */\n char *metadata_schema;\n} tsk_population_table_t;\n\n/**\n@brief The provenance table.\n\n@rst\nSee the provenance :ref:`table definition ` for\ndetails of the columns in this table.\n@endrst\n*/\ntypedef struct {\n /** @brief The number of rows in this table. */\n tsk_size_t num_rows;\n tsk_size_t max_rows;\n tsk_size_t max_rows_increment;\n /** @brief The total length of the timestamp column. */\n tsk_size_t timestamp_length;\n tsk_size_t max_timestamp_length;\n tsk_size_t max_timestamp_length_increment;\n /** @brief The total length of the record column. */\n tsk_size_t record_length;\n tsk_size_t max_record_length;\n tsk_size_t max_record_length_increment;\n /** @brief The timestamp column. */\n char *timestamp;\n /** @brief The timestamp_offset column. */\n tsk_size_t *timestamp_offset;\n /** @brief The record column. */\n char *record;\n /** @brief The record_offset column. */\n tsk_size_t *record_offset;\n} tsk_provenance_table_t;\n\ntypedef struct {\n char *data;\n tsk_size_t data_length;\n char *url;\n tsk_size_t url_length;\n char *metadata;\n tsk_size_t metadata_length;\n char *metadata_schema;\n tsk_size_t metadata_schema_length;\n} tsk_reference_sequence_t;\n\n/**\n@brief A collection of tables defining the data for a tree sequence.\n*/\ntypedef struct {\n /** @brief The sequence length defining the tree sequence's coordinate space */\n double sequence_length;\n char *file_uuid;\n /** @brief The units of the time dimension */\n char *time_units;\n tsk_size_t time_units_length;\n /** @brief The tree-sequence metadata */\n char *metadata;\n tsk_size_t metadata_length;\n /** @brief The metadata schema */\n char *metadata_schema;\n tsk_size_t metadata_schema_length;\n tsk_reference_sequence_t reference_sequence;\n /** @brief The individual table */\n tsk_individual_table_t individuals;\n /** @brief The node table */\n tsk_node_table_t nodes;\n /** @brief The edge table */\n tsk_edge_table_t edges;\n /** @brief The migration table */\n tsk_migration_table_t migrations;\n /** @brief The site table */\n tsk_site_table_t sites;\n /** @brief The mutation table */\n tsk_mutation_table_t mutations;\n /** @brief The population table */\n tsk_population_table_t populations;\n /** @brief The provenance table */\n tsk_provenance_table_t provenances;\n struct {\n tsk_id_t *edge_insertion_order;\n tsk_id_t *edge_removal_order;\n tsk_size_t num_edges;\n } indexes;\n} tsk_table_collection_t;\n\n/**\n@brief A bookmark recording the position of all the tables in a table collection.\n*/\ntypedef struct {\n /** @brief The position in the individual table. */\n tsk_size_t individuals;\n /** @brief The position in the node table. */\n tsk_size_t nodes;\n /** @brief The position in the edge table. */\n tsk_size_t edges;\n /** @brief The position in the migration table. */\n tsk_size_t migrations;\n /** @brief The position in the site table. */\n tsk_size_t sites;\n /** @brief The position in the mutation table. */\n tsk_size_t mutations;\n /** @brief The position in the population table. */\n tsk_size_t populations;\n /** @brief The position in the provenance table. */\n tsk_size_t provenances;\n} tsk_bookmark_t;\n\n/**\n@brief Low-level table sorting method.\n*/\ntypedef struct _tsk_table_sorter_t {\n /** @brief The input tables that are being sorted. */\n tsk_table_collection_t *tables;\n /** @brief The edge sorting function. If set to NULL, edges are not sorted. */\n int (*sort_edges)(struct _tsk_table_sorter_t *self, tsk_size_t start);\n /** @brief The mutation sorting function. */\n int (*sort_mutations)(struct _tsk_table_sorter_t *self);\n /** @brief The individual sorting function. */\n int (*sort_individuals)(struct _tsk_table_sorter_t *self);\n /** @brief An opaque pointer for use by client code */\n void *user_data;\n /** @brief Mapping from input site IDs to output site IDs */\n tsk_id_t *site_id_map;\n} tsk_table_sorter_t;\n\n/* Structs for IBD finding.\n * TODO: document properly\n * */\n\n/* Note for tskit developers: it's perhaps a bit confusing/pointless to\n * have the tsk_identity_segment_t struct as well as the internal tsk_segment_t\n * struct (which is identical). However, we may want to implement either\n * segment type differently in future, and since the tsk_identity_segment_t\n * is part of the public API we want to allow the freedom for the different\n * structures to evolve over time */\ntypedef struct _tsk_identity_segment_t {\n double left;\n double right;\n struct _tsk_identity_segment_t *next;\n tsk_id_t node;\n} tsk_identity_segment_t;\n\ntypedef struct {\n tsk_size_t num_segments;\n double total_span;\n tsk_identity_segment_t *head;\n tsk_identity_segment_t *tail;\n} tsk_identity_segment_list_t;\n\ntypedef struct {\n tsk_size_t num_nodes;\n tsk_avl_tree_int_t pair_map;\n tsk_size_t num_segments;\n double total_span;\n tsk_blkalloc_t heap;\n bool store_segments;\n bool store_pairs;\n} tsk_identity_segments_t;\n\n/* Diff iterator. */\ntypedef struct _tsk_edge_list_node_t {\n tsk_edge_t edge;\n struct _tsk_edge_list_node_t *next;\n struct _tsk_edge_list_node_t *prev;\n} tsk_edge_list_node_t;\n\ntypedef struct {\n tsk_edge_list_node_t *head;\n tsk_edge_list_node_t *tail;\n} tsk_edge_list_t;\n\n/****************************************************************************/\n/* Common function options */\n/****************************************************************************/\n\n/**\n@defgroup API_FLAGS_SIMPLIFY_GROUP :c:func:`tsk_table_collection_simplify` and\n:c:func:`tsk_treeseq_simplify` specific flags.\n@{\n*/\n/** Remove sites from the output if there are no mutations that reference them.*/\n#define TSK_SIMPLIFY_FILTER_SITES (1 << 0)\n/** Remove populations from the output if there are no nodes or migrations that\nreference them. */\n#define TSK_SIMPLIFY_FILTER_POPULATIONS (1 << 1)\n/** Remove individuals from the output if there are no nodes that reference them.*/\n#define TSK_SIMPLIFY_FILTER_INDIVIDUALS (1 << 2)\n/** Do not remove nodes from the output if there are no edges that reference\nthem and do not reorder nodes so that the samples are nodes 0 to num_samples - 1.\nNote that this flag is negated compared to other filtering options because\nthe default behaviour is to filter unreferenced nodes and reorder to put samples\nfirst.\n*/\n#define TSK_SIMPLIFY_NO_FILTER_NODES (1 << 7)\n/**\nDo not update the sample status of nodes as a result of simplification.\n*/\n#define TSK_SIMPLIFY_NO_UPDATE_SAMPLE_FLAGS (1 << 8)\n/**\nReduce the topological information in the tables to the minimum necessary to\nrepresent the trees that contain sites. If there are zero sites this will\nresult in an zero output edges. When the number of sites is greater than zero,\nevery tree in the output tree sequence will contain at least one site.\nFor a given site, the topology of the tree containing that site will be\nidentical (up to node ID remapping) to the topology of the corresponding tree\nin the input.\n*/\n#define TSK_SIMPLIFY_REDUCE_TO_SITE_TOPOLOGY (1 << 3)\n/**\nBy default simplify removes unary nodes (i.e., nodes with exactly one child)\nalong the path from samples to root. If this option is specified such unary\nnodes will be preserved in the output.\n*/\n#define TSK_SIMPLIFY_KEEP_UNARY (1 << 4)\n/**\nBy default simplify removes all topology ancestral the MRCAs of the samples.\nThis option inserts edges from these MRCAs back to the roots of the input\ntrees.\n*/\n#define TSK_SIMPLIFY_KEEP_INPUT_ROOTS (1 << 5)\n/**\n@rst\nThis acts like :c:macro:`TSK_SIMPLIFY_KEEP_UNARY` (and is mutually exclusive with that\nflag). It keeps unary nodes, but only if the unary node is referenced from an individual.\n@endrst\n*/\n#define TSK_SIMPLIFY_KEEP_UNARY_IN_INDIVIDUALS (1 << 6)\n/** @} */\n\n/**\n@defgroup API_FLAGS_SUBSET_GROUP :c:func:`tsk_table_collection_subset` specific flags.\n@{\n*/\n/**If this flag is provided, the population table will not be changed in any way.*/\n#define TSK_SUBSET_NO_CHANGE_POPULATIONS (1 << 0)\n/**\n@rst\nIf this flag is provided, then unreferenced sites, individuals, and populations\nwill not be removed. If so, the site and individual tables will not be changed,\nand (unless :c:macro:`TSK_SUBSET_NO_CHANGE_POPULATIONS` is also provided) unreferenced\npopulations will be placed last, in their original order.\n@endrst\n*/\n#define TSK_SUBSET_KEEP_UNREFERENCED (1 << 1)\n/** @} */\n\n/**\n@defgroup API_FLAGS_CHECK_INTEGRITY_GROUP :c:func:`tsk_table_collection_check_integrity`\nspecific flags.\n@{\n*/\n/** Check edge ordering constraints for a tree sequence. */\n#define TSK_CHECK_EDGE_ORDERING (1 << 0)\n/** Check that sites are in non-decreasing position order. */\n#define TSK_CHECK_SITE_ORDERING (1 << 1)\n/**Check for any duplicate site positions. */\n#define TSK_CHECK_SITE_DUPLICATES (1 << 2)\n/**\nCheck constraints on the ordering of mutations. Any non-null\nmutation parents and known times are checked for ordering\nconstraints.\n*/\n#define TSK_CHECK_MUTATION_ORDERING (1 << 3)\n/**Check individual parents are before children, where specified. */\n#define TSK_CHECK_INDIVIDUAL_ORDERING (1 << 4)\n/**Check migrations are ordered by time. */\n#define TSK_CHECK_MIGRATION_ORDERING (1 << 5)\n/**Check that the table indexes exist, and contain valid edge references. */\n#define TSK_CHECK_INDEXES (1 << 6)\n/**\nAll checks needed to define a valid tree sequence. Note that\nthis implies all of the above checks.\n*/\n#define TSK_CHECK_TREES (1 << 7)\n/**\nCheck mutation parents are consistent with topology.\nImplies TSK_CHECK_TREES.\n*/\n#define TSK_CHECK_MUTATION_PARENTS (1 << 8)\n\n/* Leave room for more positive check flags */\n/**\nDo not check integrity of references to populations. This\ncan be safely combined with the other checks.\n*/\n#define TSK_NO_CHECK_POPULATION_REFS (1 << 12)\n/** @} */\n\n/**\n@defgroup API_FLAGS_LOAD_INIT_GROUP Flags used by load and init methods.\n@{\n*/\n/* These flags are for table collection load or init, or used as\n flags on table collection or individual tables.\n * As flags are passed though from load to init they share a namespace */\n/** Skip reading tables, and only load top-level information. */\n#define TSK_LOAD_SKIP_TABLES (1 << 0)\n/** Do not load reference sequence. */\n#define TSK_LOAD_SKIP_REFERENCE_SEQUENCE (1 << 1)\n/**\n@rst\nDo not allocate space to store metadata in this table. Operations\nattempting to add non-empty metadata to the table will fail\nwith error TSK_ERR_METADATA_DISABLED.\n@endrst\n*/\n#define TSK_TABLE_NO_METADATA (1 << 2)\n/**\n@rst\nDo not allocate space to store metadata in the edge table. Operations\nattempting to add non-empty metadata to the edge table will fail\nwith error TSK_ERR_METADATA_DISABLED.\n@endrst\n*/\n#define TSK_TC_NO_EDGE_METADATA (1 << 3)\n/** @} */\n\n/* Flags for dump tables */\n/* We may not want to document this flag, but it's useful for testing\n * so we put it high up in the bit space, below the common options */\n#define TSK_DUMP_FORCE_OFFSET_64 (1 << 27)\n\n/**\n@defgroup API_FLAGS_COPY_GROUP Flags used by :c:func:`tsk_table_collection_copy`.\n@{\n*/\n/** Copy the file uuid, by default this is not copied. */\n#define TSK_COPY_FILE_UUID (1 << 0)\n/** @} */\n\n/**\n@defgroup API_FLAGS_UNION_GROUP Flags used by :c:func:`tsk_table_collection_union`.\n@{\n*/\n/**\nBy default, union checks that the portion of shared history between\n``self`` and ``other``, as implied by ``other_node_mapping``, are indeed\nequivalent. It does so by subsetting both ``self`` and ``other`` on the\nequivalent nodes specified in ``other_node_mapping``, and then checking for\nequality of the subsets.\n*/\n#define TSK_UNION_NO_CHECK_SHARED (1 << 0)\n/**\nBy default, all nodes new to ``self`` are assigned new populations. If this\noption is specified, nodes that are added to ``self`` will retain the\npopulation IDs they have in ``other``.\n */\n#define TSK_UNION_NO_ADD_POP (1 << 1)\n/**\nBy default, union only adds edges adjacent to a newly added node;\nthis option adds all edges.\n */\n#define TSK_UNION_ALL_EDGES (1 << 2)\n/**\nBy default, union only adds only mutations on newly added edges, and\nsites for those mutations; this option adds all mutations and all sites.\n */\n#define TSK_UNION_ALL_MUTATIONS (1 << 3)\n/** @} */\n\n/**\n@defgroup API_FLAGS_CMP_GROUP Flags used by :c:func:`tsk_table_collection_equals`.\n@{\n*/\n/**\nDo not include the top-level tree sequence metadata and metadata schemas\nin the comparison.\n*/\n#define TSK_CMP_IGNORE_TS_METADATA (1 << 0)\n/** Do not include the provenance table in comparison. */\n#define TSK_CMP_IGNORE_PROVENANCE (1 << 1)\n/**\n@rst\nDo not include metadata when comparing the table collections.\nThis includes both the top-level tree sequence metadata as well as the\nmetadata for each of the tables (i.e, :c:macro:`TSK_CMP_IGNORE_TS_METADATA` is implied).\nAll metadata schemas are also ignored.\n@endrst\n*/\n#define TSK_CMP_IGNORE_METADATA (1 << 2)\n/**\n@rst\nDo not include the timestamp information when comparing the provenance\ntables. This has no effect if :c:macro:`TSK_CMP_IGNORE_PROVENANCE` is specified.\n@endrst\n*/\n#define TSK_CMP_IGNORE_TIMESTAMPS (1 << 3)\n/**\nDo not include any tables in the comparison, thus comparing only the\ntop-level information of the table collections being compared.\n*/\n#define TSK_CMP_IGNORE_TABLES (1 << 4)\n/** Do not include the reference sequence in the comparison. */\n#define TSK_CMP_IGNORE_REFERENCE_SEQUENCE (1 << 5)\n/** @} */\n\n/**\n@defgroup API_FLAGS_CLEAR_GROUP Flags used by :c:func:`tsk_table_collection_clear`.\n@{\n*/\n/** Additionally clear the table metadata schemas*/\n#define TSK_CLEAR_METADATA_SCHEMAS (1 << 0)\n/** Additionally clear the tree-sequence metadata and schema*/\n#define TSK_CLEAR_TS_METADATA_AND_SCHEMA (1 << 1)\n/** Additionally clear the provenance table*/\n#define TSK_CLEAR_PROVENANCE (1 << 2)\n/** @} */\n\n/* For the edge diff iterator */\n#define TSK_INCLUDE_TERMINAL (1 << 0)\n\n/** @brief Value returned by seeking methods when they have successfully\n seeked to a non-null tree.\n\n @ingroup TREE_API_SEEKING_GROUP\n*/\n#define TSK_TREE_OK 1\n\n/****************************************************************************/\n/* Function signatures */\n/****************************************************************************/\n\n/**\n@defgroup INDIVIDUAL_TABLE_API_GROUP Individual table API.\n@{\n*/\n\n/**\n@brief Initialises the table by allocating the internal memory.\n\n@rst\nThis must be called before any operations are performed on the table.\nSee the :ref:`sec_c_api_overview_structure` for details on how objects\nare initialised and freed.\n@endrst\n\n@param self A pointer to an uninitialised tsk_individual_table_t object.\n@param options Allocation time options. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_individual_table_init(tsk_individual_table_t *self, tsk_flags_t options);\n\n/**\n@brief Free the internal memory for the specified table.\n\n@param self A pointer to an initialised tsk_individual_table_t object.\n@return Always returns 0.\n*/\nint tsk_individual_table_free(tsk_individual_table_t *self);\n\n/**\n@brief Adds a row to this individual table.\n\n@rst\nAdd a new individual with the specified ``flags``, ``location``, ``parents`` and\n``metadata`` to the table. Copies of the ``location``, ``parents`` and ``metadata``\nparameters are taken immediately. See the :ref:`table definition\n` for details of the columns in this table.\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object.\n@param flags The bitwise flags for the new individual.\n@param location A pointer to a double array representing the spatial location\n of the new individual. Can be ``NULL`` if ``location_length`` is 0.\n@param location_length The number of dimensions in the locations position.\n Note this the number of elements in the corresponding double array\n not the number of bytes.\n@param parents A pointer to a ``tsk_id`` array representing the parents\n of the new individual. Can be ``NULL`` if ``parents_length`` is 0.\n@param parents_length The number of parents.\n Note this the number of elements in the corresponding ``tsk_id`` array\n not the number of bytes.\n@param metadata The metadata to be associated with the new individual. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``metadata_length`` is 0.\n@param metadata_length The size of the metadata array in bytes.\n@return Return the ID of the newly added individual on success,\n or a negative value on failure.\n*/\ntsk_id_t tsk_individual_table_add_row(tsk_individual_table_t *self, tsk_flags_t flags,\n const double *location, tsk_size_t location_length, const tsk_id_t *parents,\n tsk_size_t parents_length, const char *metadata, tsk_size_t metadata_length);\n\n/**\n@brief Updates the row at the specified index.\n\n@rst\nRewrite the row at the specified index in this table to use the specified\nvalues. Copies of the ``location``, ``parents`` and ``metadata``\nparameters are taken immediately. See the :ref:`table definition\n` for details of the columns in this table.\n\n.. warning::\n Because of the way that ragged columns are encoded, this method requires a\n full rewrite of the internal column memory in worst case, and would\n therefore be inefficient for bulk updates for such columns. However, if the\n sizes of all ragged column values are unchanged in the updated row, this\n method is guaranteed to only update the memory for the row in question.\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object.\n@param index The row to update.\n@param flags The bitwise flags for the individual.\n@param location A pointer to a double array representing the spatial location\n of the new individual. Can be ``NULL`` if ``location_length`` is 0.\n@param location_length The number of dimensions in the locations position.\n Note this the number of elements in the corresponding double array\n not the number of bytes.\n@param parents A pointer to a ``tsk_id`` array representing the parents\n of the new individual. Can be ``NULL`` if ``parents_length`` is 0.\n@param parents_length The number of parents.\n Note this the number of elements in the corresponding ``tsk_id`` array\n not the number of bytes.\n@param metadata The metadata to be associated with the new individual. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``metadata_length`` is 0.\n@param metadata_length The size of the metadata array in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_individual_table_update_row(tsk_individual_table_t *self, tsk_id_t index,\n tsk_flags_t flags, const double *location, tsk_size_t location_length,\n const tsk_id_t *parents, tsk_size_t parents_length, const char *metadata,\n tsk_size_t metadata_length);\n\n/**\n@brief Clears this table, setting the number of rows to zero.\n\n@rst\nNo memory is freed as a result of this operation; please use\n:c:func:`tsk_individual_table_free` to free the table's internal resources. Note that the\nmetadata schema is not cleared.\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_individual_table_clear(tsk_individual_table_t *self);\n\n/**\n@brief Truncates this table so that only the first num_rows are retained.\n\n@param self A pointer to a tsk_individual_table_t object.\n@param num_rows The number of rows to retain in the table.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_individual_table_truncate(tsk_individual_table_t *self, tsk_size_t num_rows);\n\n/**\n@brief Extends this table by appending rows copied from another table.\n\n@rst\nAppends the rows at the specified indexes from the table ``other`` to the end of this\ntable. Row indexes can be repeated and in any order. If ``row_indexes`` is NULL, append\nthe first ``num_rows`` from ``other`` to this table. Note that metadata is copied as-is\nand is not checked for compatibility with any existing schema on this table.\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object where rows are to be added.\n@param other A pointer to a tsk_individual_table_t object where rows are copied from.\n@param num_rows The number of rows from ``other`` to append to this table.\n@param row_indexes Array of row indexes in ``other``. If ``NULL`` is passed then the\n first ``num_rows`` of ``other`` are used.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_individual_table_extend(tsk_individual_table_t *self,\n const tsk_individual_table_t *other, tsk_size_t num_rows,\n const tsk_id_t *row_indexes, tsk_flags_t options);\n\n/**\n@brief Subset this table by keeping rows according to a boolean mask.\n\n@rst\nDeletes rows from this table and optionally return the mapping from IDs in\nthe current table to the updated table. Rows are kept or deleted according to\nthe specified boolean array ``keep`` such that for each row ``j`` if\n``keep[j]`` is false (zero) the row is deleted, and otherwise the row is\nretained. Thus, ``keep`` must be an array of at least ``num_rows``\n:c:type:`bool` values.\n\nIf the ``id_map`` argument is non-null, this array will be updated to represent\nthe mapping between IDs before and after row deletion. For row ``j``,\n``id_map[j]`` will contain the new ID for row ``j`` if it is retained, or\n:c:macro:`TSK_NULL` if the row has been removed. Thus, ``id_map`` must be an\narray of at least ``num_rows`` :c:type:`tsk_id_t` values.\n\nThe values in the ``parents`` column are updated according to this map, so that\nreference integrity within the table is maintained. As a consequence of this,\nthe values in the ``parents`` column for kept rows are bounds-checked and an\nerror raised if they are not valid. Rows that are deleted are not checked for\nparent ID integrity.\n\nIf an attempt is made to delete rows that are referred to by the ``parents``\ncolumn of rows that are retained, an error is raised.\n\nThese error conditions are checked before any alterations to the table are\nmade.\n\n.. warning::\n C++ users need to be careful to specify the correct type when\n passing in values for the ``keep`` array,\n using ``std::vector`` and not ``std::vector``,\n as the latter may not be correct size.\n\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object.\n@param keep Array of boolean flags describing whether a particular\n row should be kept or not. Must be at least ``num_rows`` long.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@param id_map An array in which to store the mapping between new\n and old IDs. If NULL, this will be ignored.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_individual_table_keep_rows(tsk_individual_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t options, tsk_id_t *id_map);\n\n/**\n@brief Returns true if the data in the specified table is identical to the data\n in this table.\n\n@rst\n\n**Options**\n\nOptions to control the comparison can be specified by providing one or\nmore of the following bitwise flags. By default (options=0) tables are\nconsidered equal if they are byte-wise identical in all columns,\nand their metadata schemas are byte-wise identical.\n\n- :c:macro:`TSK_CMP_IGNORE_METADATA`\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object.\n@param other A pointer to a tsk_individual_table_t object.\n@param options Bitwise comparison options.\n@return Return true if the specified table is equal to this table.\n*/\nbool tsk_individual_table_equals(const tsk_individual_table_t *self,\n const tsk_individual_table_t *other, tsk_flags_t options);\n\n/**\n@brief Copies the state of this table into the specified destination.\n\n@rst\nBy default the method initialises the specified destination table. If the\ndestination is already initialised, the :c:macro:`TSK_NO_INIT` option should\nbe supplied to avoid leaking memory.\n\nIndexes that are present are also copied to the destination table.\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object.\n@param dest A pointer to a tsk_individual_table_t object. If the TSK_NO_INIT\noption is specified, this must be an initialised individual table. If not, it must be an\nuninitialised individual table.\n@param options Bitwise option flags.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_individual_table_copy(const tsk_individual_table_t *self,\n tsk_individual_table_t *dest, tsk_flags_t options);\n\n/**\n@brief Get the row at the specified index.\n\n@rst\nUpdates the specified individual struct to reflect the values in the specified row.\nPointers to memory within this struct are handled by the table and should **not**\nbe freed by client code. These pointers are guaranteed to be valid until the\nnext operation that modifies the table (e.g., by adding a new row), but not afterwards.\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object.\n@param index The requested table row.\n@param row A pointer to a tsk_individual_t struct that is updated to reflect the\n values in the specified row.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_individual_table_get_row(\n const tsk_individual_table_t *self, tsk_id_t index, tsk_individual_t *row);\n\n/**\n@brief Set the metadata schema\n\n@rst\nCopies the metadata schema string to this table, replacing any existing.\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object.\n@param metadata_schema A pointer to a char array.\n@param metadata_schema_length The size of the metadata schema in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_individual_table_set_metadata_schema(tsk_individual_table_t *self,\n const char *metadata_schema, tsk_size_t metadata_schema_length);\n\n/**\n@brief Print out the state of this table to the specified stream.\n\nThis method is intended for debugging purposes and should not be used\nin production code. The format of the output should **not** be depended\non and may change arbitrarily between versions.\n\n@param self A pointer to a tsk_individual_table_t object.\n@param out The stream to write the summary to.\n*/\nvoid tsk_individual_table_print_state(const tsk_individual_table_t *self, FILE *out);\n\n/**\n@brief Replace this table's data by copying from a set of column arrays\n\n@rst\nClears the data columns of this table and then copies column data from the specified\nset of arrays. The supplied arrays should all contain data on the same number of rows.\nThe metadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays.\n@param flags The array of tsk_flag_t flag values to be copied.\n@param location The array of double location values to be copied.\n@param location_offset The array of tsk_size_t location offset values to be copied.\n@param parents The array of tsk_id_t parent values to be copied.\n@param parents_offset The array of tsk_size_t parent offset values to be copied.\n@param metadata The array of char metadata values to be copied.\n@param metadata_offset The array of tsk_size_t metadata offset values to be copied.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_individual_table_set_columns(tsk_individual_table_t *self, tsk_size_t num_rows,\n const tsk_flags_t *flags, const double *location, const tsk_size_t *location_offset,\n const tsk_id_t *parents, const tsk_size_t *parents_offset, const char *metadata,\n const tsk_size_t *metadata_offset);\n\n/**\n@brief Extends this table by copying from a set of column arrays\n\n@rst\nCopies column data from the specified set of arrays to create new rows at the end of the\ntable. The supplied arrays should all contain data on the same number of rows. The\nmetadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays\n@param flags The array of tsk_flag_t flag values to be copied.\n@param location The array of double location values to be copied.\n@param location_offset The array of tsk_size_t location offset values to be copied.\n@param parents The array of tsk_id_t parent values to be copied.\n@param parents_offset The array of tsk_size_t parent offset values to be copied.\n@param metadata The array of char metadata values to be copied.\n@param metadata_offset The array of tsk_size_t metadata offset values to be copied.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_individual_table_append_columns(tsk_individual_table_t *self,\n tsk_size_t num_rows, const tsk_flags_t *flags, const double *location,\n const tsk_size_t *location_offset, const tsk_id_t *parents,\n const tsk_size_t *parents_offset, const char *metadata,\n const tsk_size_t *metadata_offset);\n\n/**\n@brief Controls the pre-allocation strategy for this table\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object.\n@param max_rows_increment The number of rows to pre-allocate, or zero for the default\n doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_individual_table_set_max_rows_increment(\n tsk_individual_table_t *self, tsk_size_t max_rows_increment);\n\n/**\n@brief Controls the pre-allocation strategy for the metadata column\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object.\n@param max_metadata_length_increment The number of bytes to pre-allocate, or zero for\nthe default doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_individual_table_set_max_metadata_length_increment(\n tsk_individual_table_t *self, tsk_size_t max_metadata_length_increment);\n\n/**\n@brief Controls the pre-allocation strategy for the location column\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object.\n@param max_location_length_increment The number of bytes to pre-allocate, or zero for\nthe default doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_individual_table_set_max_location_length_increment(\n tsk_individual_table_t *self, tsk_size_t max_location_length_increment);\n\n/**\n@brief Controls the pre-allocation strategy for the parents column\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object.\n@param max_parents_length_increment The number of bytes to pre-allocate, or zero for\nthe default doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_individual_table_set_max_parents_length_increment(\n tsk_individual_table_t *self, tsk_size_t max_parents_length_increment);\n\n/** @} */\n\n/* Undocumented methods */\n\nint tsk_individual_table_dump_text(const tsk_individual_table_t *self, FILE *out);\n/**\n@defgroup NODE_TABLE_API_GROUP Node table API.\n@{\n*/\n\n/**\n@brief Initialises the table by allocating the internal memory.\n\n@rst\nThis must be called before any operations are performed on the table.\nSee the :ref:`sec_c_api_overview_structure` for details on how objects\nare initialised and freed.\n@endrst\n\n@param self A pointer to an uninitialised tsk_node_table_t object.\n@param options Allocation time options. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_node_table_init(tsk_node_table_t *self, tsk_flags_t options);\n\n/**\n@brief Free the internal memory for the specified table.\n\n@param self A pointer to an initialised tsk_node_table_t object.\n@return Always returns 0.\n*/\nint tsk_node_table_free(tsk_node_table_t *self);\n\n/**\n@brief Adds a row to this node table.\n\n@rst\nAdd a new node with the specified ``flags``, ``time``, ``population``,\n``individual`` and ``metadata`` to the table. A copy of the ``metadata`` parameter\nis taken immediately. See the :ref:`table definition `\nfor details of the columns in this table.\n@endrst\n\n@param self A pointer to a tsk_node_table_t object.\n@param flags The bitwise flags for the new node.\n@param time The time for the new node.\n@param population The population for the new node. Set to TSK_NULL if not\nknown.\n@param individual The individual for the new node. Set to TSK_NULL if not\nknown.\n@param metadata The metadata to be associated with the new node. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``metadata_length`` is 0.\n@param metadata_length The size of the metadata array in bytes.\n@return Return the ID of the newly added node on success,\n or a negative value on failure.\n*/\ntsk_id_t tsk_node_table_add_row(tsk_node_table_t *self, tsk_flags_t flags, double time,\n tsk_id_t population, tsk_id_t individual, const char *metadata,\n tsk_size_t metadata_length);\n\n/**\n@brief Updates the row at the specified index.\n\n@rst\nRewrite the row at the specified index in this table to use the specified\nvalues. A copy of the ``metadata`` parameter is taken immediately. See the\n:ref:`table definition ` for details of the columns\nin this table.\n\n.. warning::\n Because of the way that ragged columns are encoded, this method requires a\n full rewrite of the internal column memory in worst case, and would\n therefore be inefficient for bulk updates for such columns. However, if the\n sizes of all ragged column values are unchanged in the updated row, this\n method is guaranteed to only update the memory for the row in question.\n@endrst\n\n@param self A pointer to a tsk_node_table_t object.\n@param index The row to update.\n@param flags The bitwise flags for the node.\n@param time The time for the node.\n@param population The population for the node. Set to TSK_NULL if not known.\n@param individual The individual for the node. Set to TSK_NULL if not known.\n@param metadata The metadata to be associated with the node. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``metadata_length`` is 0.\n@param metadata_length The size of the metadata array in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_node_table_update_row(tsk_node_table_t *self, tsk_id_t index, tsk_flags_t flags,\n double time, tsk_id_t population, tsk_id_t individual, const char *metadata,\n tsk_size_t metadata_length);\n\n/**\n@brief Clears this table, setting the number of rows to zero.\n\n@rst\nNo memory is freed as a result of this operation; please use\n:c:func:`tsk_node_table_free` to free the table's internal resources. Note that the\nmetadata schema is not cleared.\n@endrst\n\n@param self A pointer to a tsk_node_table_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_node_table_clear(tsk_node_table_t *self);\n\n/**\n@brief Truncates this table so that only the first num_rows are retained.\n\n@param self A pointer to a tsk_node_table_t object.\n@param num_rows The number of rows to retain in the table.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_node_table_truncate(tsk_node_table_t *self, tsk_size_t num_rows);\n\n/**\n@brief Extends this table by appending rows copied from another table.\n\n@rst\nAppends the rows at the specified indexes from the table ``other`` to the end of this\ntable. Row indexes can be repeated and in any order. If ``row_indexes`` is NULL, append\nthe first ``num_rows`` from ``other`` to this table. Note that metadata is copied as-is\nand is not checked for compatibility with any existing schema on this table.\n@endrst\n\n@param self A pointer to a tsk_node_table_t object where rows are to be added.\n@param other A pointer to a tsk_node_table_t object where rows are copied from.\n@param num_rows The number of rows from ``other`` to append to this table.\n@param row_indexes Array of row indexes in ``other``. If ``NULL`` is passed then the\n first ``num_rows`` of ``other`` are used.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_node_table_extend(tsk_node_table_t *self, const tsk_node_table_t *other,\n tsk_size_t num_rows, const tsk_id_t *row_indexes, tsk_flags_t options);\n\n/**\n@brief Subset this table by keeping rows according to a boolean mask.\n\n@rst\nDeletes rows from this table and optionally return the mapping from IDs in\nthe current table to the updated table. Rows are kept or deleted according to\nthe specified boolean array ``keep`` such that for each row ``j`` if\n``keep[j]`` is false (zero) the row is deleted, and otherwise the row is\nretained. Thus, ``keep`` must be an array of at least ``num_rows``\n:c:type:`bool` values.\n\nIf the ``id_map`` argument is non-null, this array will be updated to represent\nthe mapping between IDs before and after row deletion. For row ``j``,\n``id_map[j]`` will contain the new ID for row ``j`` if it is retained, or\n:c:macro:`TSK_NULL` if the row has been removed. Thus, ``id_map`` must be an\narray of at least ``num_rows`` :c:type:`tsk_id_t` values.\n\n.. warning::\n C++ users need to be careful to specify the correct type when\n passing in values for the ``keep`` array,\n using ``std::vector`` and not ``std::vector``,\n as the latter may not be correct size.\n\n@endrst\n\n@param self A pointer to a tsk_node_table_t object.\n@param keep Array of boolean flags describing whether a particular\n row should be kept or not. Must be at least ``num_rows`` long.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@param id_map An array in which to store the mapping between new\n and old IDs. If NULL, this will be ignored.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_node_table_keep_rows(tsk_node_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t options, tsk_id_t *id_map);\n\n/**\n@brief Returns true if the data in the specified table is identical to the data\n in this table.\n\n@rst\n\n**Options**\n\nOptions to control the comparison can be specified by providing one or\nmore of the following bitwise flags. By default (options=0) tables are\nconsidered equal if they are byte-wise identical in all columns,\nand their metadata schemas are byte-wise identical.\n\n- :c:macro:`TSK_CMP_IGNORE_METADATA`\n@endrst\n\n@param self A pointer to a tsk_node_table_t object.\n@param other A pointer to a tsk_node_table_t object.\n@param options Bitwise comparison options.\n@return Return true if the specified table is equal to this table.\n*/\nbool tsk_node_table_equals(\n const tsk_node_table_t *self, const tsk_node_table_t *other, tsk_flags_t options);\n\n/**\n@brief Copies the state of this table into the specified destination.\n\n@rst\nBy default the method initialises the specified destination table. If the\ndestination is already initialised, the TSK_NO_INIT option should\nbe supplied to avoid leaking memory.\n@endrst\n\n@param self A pointer to a tsk_node_table_t object.\n@param dest A pointer to a tsk_node_table_t object. If the TSK_NO_INIT option\n is specified, this must be an initialised node table. If not, it must\n be an uninitialised node table.\n@param options Bitwise option flags.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_node_table_copy(\n const tsk_node_table_t *self, tsk_node_table_t *dest, tsk_flags_t options);\n\n/**\n@brief Get the row at the specified index.\n\n@rst\nUpdates the specified node struct to reflect the values in the specified row.\nPointers to memory within this struct are handled by the table and should **not**\nbe freed by client code. These pointers are guaranteed to be valid until the\nnext operation that modifies the table (e.g., by adding a new row), but not afterwards.\n@endrst\n\n@param self A pointer to a tsk_node_table_t object.\n@param index The requested table row.\n@param row A pointer to a tsk_node_t struct that is updated to reflect the\n values in the specified row.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_node_table_get_row(\n const tsk_node_table_t *self, tsk_id_t index, tsk_node_t *row);\n\n/**\n@brief Set the metadata schema\n@rst\nCopies the metadata schema string to this table, replacing any existing.\n@endrst\n@param self A pointer to a tsk_node_table_t object.\n@param metadata_schema A pointer to a char array.\n@param metadata_schema_length The size of the metadata schema in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_node_table_set_metadata_schema(tsk_node_table_t *self,\n const char *metadata_schema, tsk_size_t metadata_schema_length);\n\n/**\n@brief Print out the state of this table to the specified stream.\n\nThis method is intended for debugging purposes and should not be used\nin production code. The format of the output should **not** be depended\non and may change arbitrarily between versions.\n\n@param self A pointer to a tsk_node_table_t object.\n@param out The stream to write the summary to.\n*/\nvoid tsk_node_table_print_state(const tsk_node_table_t *self, FILE *out);\n\n/**\n@brief Replace this table's data by copying from a set of column arrays\n\n@rst\nClears the data columns of this table and then copies column data from the specified\nset of arrays. The supplied arrays should all contain data on the same number of rows.\nThe metadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_node_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays.\n@param flags The array of tsk_flag_t values to be copied.\n@param time The array of double time values to be copied.\n@param population The array of tsk_id_t population values to be copied.\n@param individual The array of tsk_id_t individual values to be copied.\n@param metadata The array of char metadata values to be copied.\n@param metadata_offset The array of tsk_size_t metadata offset values to be copied.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_node_table_set_columns(tsk_node_table_t *self, tsk_size_t num_rows,\n const tsk_flags_t *flags, const double *time, const tsk_id_t *population,\n const tsk_id_t *individual, const char *metadata, const tsk_size_t *metadata_offset);\n\n/**\n@brief Extends this table by copying from a set of column arrays\n\n@rst\nCopies column data from the specified set of arrays to create new rows at the end of the\ntable. The supplied arrays should all contain data on the same number of rows. The\nmetadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_node_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays\n@param flags The array of tsk_flag_t values to be copied.\n@param time The array of double time values to be copied.\n@param population The array of tsk_id_t population values to be copied.\n@param individual The array of tsk_id_t individual values to be copied.\n@param metadata The array of char metadata values to be copied.\n@param metadata_offset The array of tsk_size_t metadata offset values to be copied.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_node_table_append_columns(tsk_node_table_t *self, tsk_size_t num_rows,\n const tsk_flags_t *flags, const double *time, const tsk_id_t *population,\n const tsk_id_t *individual, const char *metadata, const tsk_size_t *metadata_offset);\n\n/**\n@brief Controls the pre-allocation strategy for this table\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_node_table_t object.\n@param max_rows_increment The number of rows to pre-allocate, or zero for the default\n doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\n\nint tsk_node_table_set_max_rows_increment(\n tsk_node_table_t *self, tsk_size_t max_rows_increment);\n\n/**\n@brief Controls the pre-allocation strategy for the metadata column\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_node_table_t object.\n@param max_metadata_length_increment The number of bytes to pre-allocate, or zero for\nthe default doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_node_table_set_max_metadata_length_increment(\n tsk_node_table_t *self, tsk_size_t max_metadata_length_increment);\n\n/** @} */\n\n/* Undocumented methods */\n\nint tsk_node_table_dump_text(const tsk_node_table_t *self, FILE *out);\n\n/**\n@defgroup EDGE_TABLE_API_GROUP Edge table API.\n@{\n*/\n\n/**\n@brief Initialises the table by allocating the internal memory.\n\n@rst\nThis must be called before any operations are performed on the table.\nSee the :ref:`sec_c_api_overview_structure` for details on how objects\nare initialised and freed.\n\n**Options**\n\nOptions can be specified by providing one or more of the following bitwise\nflags:\n\n- :c:macro:`TSK_TABLE_NO_METADATA`\n@endrst\n\n@param self A pointer to an uninitialised tsk_edge_table_t object.\n@param options Allocation time options.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_edge_table_init(tsk_edge_table_t *self, tsk_flags_t options);\n\n/**\n@brief Free the internal memory for the specified table.\n\n@param self A pointer to an initialised tsk_edge_table_t object.\n@return Always returns 0.\n*/\nint tsk_edge_table_free(tsk_edge_table_t *self);\n\n/**\n@brief Adds a row to this edge table.\n\n@rst\nAdd a new edge with the specified ``left``, ``right``, ``parent``, ``child`` and\n``metadata`` to the table. See the :ref:`table definition `\nfor details of the columns in this table.\n@endrst\n\n@param self A pointer to a tsk_edge_table_t object.\n@param left The left coordinate for the new edge.\n@param right The right coordinate for the new edge.\n@param parent The parent node for the new edge.\n@param child The child node for the new edge.\n@param metadata The metadata to be associated with the new edge. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``metadata_length`` is 0.\n@param metadata_length The size of the metadata array in bytes.\n\n@return Return the ID of the newly added edge on success,\n or a negative value on failure.\n*/\ntsk_id_t tsk_edge_table_add_row(tsk_edge_table_t *self, double left, double right,\n tsk_id_t parent, tsk_id_t child, const char *metadata, tsk_size_t metadata_length);\n\n/**\n@brief Updates the row at the specified index.\n\n@rst\nRewrite the row at the specified index in this table to use the specified\nvalues. A copy of the ``metadata`` parameter is taken immediately. See the\n:ref:`table definition ` for details of the columns\nin this table.\n\n.. warning::\n Because of the way that ragged columns are encoded, this method requires a\n full rewrite of the internal column memory in worst case, and would\n therefore be inefficient for bulk updates for such columns. However, if the\n sizes of all ragged column values are unchanged in the updated row, this\n method is guaranteed to only update the memory for the row in question.\n@endrst\n\n@param self A pointer to a tsk_edge_table_t object.\n@param index The row to update.\n@param left The left coordinate for the edge.\n@param right The right coordinate for the edge.\n@param parent The parent node for the edge.\n@param child The child node for the edge.\n@param metadata The metadata to be associated with the edge. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``metadata_length`` is 0.\n@param metadata_length The size of the metadata array in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_edge_table_update_row(tsk_edge_table_t *self, tsk_id_t index, double left,\n double right, tsk_id_t parent, tsk_id_t child, const char *metadata,\n tsk_size_t metadata_length);\n\n/**\n@brief Clears this table, setting the number of rows to zero.\n\n@rst\nNo memory is freed as a result of this operation; please use\n:c:func:`tsk_edge_table_free` to free the table's internal resources. Note that the\nmetadata schema is not cleared.\n@endrst\n\n@param self A pointer to a tsk_edge_table_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_edge_table_clear(tsk_edge_table_t *self);\n\n/**\n@brief Truncates this table so that only the first num_rows are retained.\n\n@param self A pointer to a tsk_edge_table_t object.\n@param num_rows The number of rows to retain in the table.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_edge_table_truncate(tsk_edge_table_t *self, tsk_size_t num_rows);\n\n/**\n@brief Extends this table by appending rows copied from another table.\n\n@rst\nAppends the rows at the specified indexes from the table ``other`` to the end of this\ntable. Row indexes can be repeated and in any order. If ``row_indexes`` is ``NULL``,\nappend the first ``num_rows`` from ``other`` to this table. Note that metadata is copied\nas-is and is not checked for compatibility with any existing schema on this table.\n@endrst\n\n@param self A pointer to a tsk_edge_table_t object where rows are to be added.\n@param other A pointer to a tsk_edge_table_t object where rows are copied from.\n@param num_rows The number of rows from ``other`` to append to this table.\n@param row_indexes Array of row indexes in ``other``. If ``NULL`` is passed then the\n first ``num_rows`` of ``other`` are used.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_edge_table_extend(tsk_edge_table_t *self, const tsk_edge_table_t *other,\n tsk_size_t num_rows, const tsk_id_t *row_indexes, tsk_flags_t options);\n\n/**\n@brief Subset this table by keeping rows according to a boolean mask.\n\n@rst\nDeletes rows from this table and optionally return the mapping from IDs in\nthe current table to the updated table. Rows are kept or deleted according to\nthe specified boolean array ``keep`` such that for each row ``j`` if\n``keep[j]`` is false (zero) the row is deleted, and otherwise the row is\nretained. Thus, ``keep`` must be an array of at least ``num_rows``\n:c:type:`bool` values.\n\nIf the ``id_map`` argument is non-null, this array will be updated to represent\nthe mapping between IDs before and after row deletion. For row ``j``,\n``id_map[j]`` will contain the new ID for row ``j`` if it is retained, or\n:c:macro:`TSK_NULL` if the row has been removed. Thus, ``id_map`` must be an\narray of at least ``num_rows`` :c:type:`tsk_id_t` values.\n\n.. warning::\n C++ users need to be careful to specify the correct type when\n passing in values for the ``keep`` array,\n using ``std::vector`` and not ``std::vector``,\n as the latter may not be correct size.\n\n@endrst\n\n@param self A pointer to a tsk_edge_table_t object.\n@param keep Array of boolean flags describing whether a particular\n row should be kept or not. Must be at least ``num_rows`` long.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@param id_map An array in which to store the mapping between new\n and old IDs. If NULL, this will be ignored.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_edge_table_keep_rows(tsk_edge_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t options, tsk_id_t *id_map);\n\n/**\n@brief Returns true if the data in the specified table is identical to the data\n in this table.\n\n@rst\n\n**Options**\n\nOptions to control the comparison can be specified by providing one or\nmore of the following bitwise flags. By default (options=0) tables are\nconsidered equal if they are byte-wise identical in all columns,\nand their metadata schemas are byte-wise identical.\n\n- :c:macro:`TSK_CMP_IGNORE_METADATA`\n@endrst\n\n@param self A pointer to a tsk_edge_table_t object.\n@param other A pointer to a tsk_edge_table_t object.\n@param options Bitwise comparison options.\n@return Return true if the specified table is equal to this table.\n*/\nbool tsk_edge_table_equals(\n const tsk_edge_table_t *self, const tsk_edge_table_t *other, tsk_flags_t options);\n\n/**\n@brief Copies the state of this table into the specified destination.\n\n@rst\nBy default the method initialises the specified destination table. If the\ndestination is already initialised, the :c:macro:`TSK_NO_INIT` option should\nbe supplied to avoid leaking memory.\n@endrst\n\n@param self A pointer to a tsk_edge_table_t object.\n@param dest A pointer to a tsk_edge_table_t object. If the TSK_NO_INIT option\n is specified, this must be an initialised edge table. If not, it must\n be an uninitialised edge table.\n@param options Bitwise option flags.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_edge_table_copy(\n const tsk_edge_table_t *self, tsk_edge_table_t *dest, tsk_flags_t options);\n\n/**\n@brief Get the row at the specified index.\n\n@rst\nUpdates the specified edge struct to reflect the values in the specified row.\nPointers to memory within this struct are handled by the table and should **not**\nbe freed by client code. These pointers are guaranteed to be valid until the\nnext operation that modifies the table (e.g., by adding a new row), but not afterwards.\n@endrst\n\n@param self A pointer to a tsk_edge_table_t object.\n@param index The requested table row.\n@param row A pointer to a tsk_edge_t struct that is updated to reflect the\n values in the specified row.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_edge_table_get_row(\n const tsk_edge_table_t *self, tsk_id_t index, tsk_edge_t *row);\n\n/**\n@brief Set the metadata schema\n@rst\nCopies the metadata schema string to this table, replacing any existing.\n@endrst\n@param self A pointer to a tsk_edge_table_t object.\n@param metadata_schema A pointer to a char array\n@param metadata_schema_length The size of the metadata schema in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_edge_table_set_metadata_schema(tsk_edge_table_t *self,\n const char *metadata_schema, tsk_size_t metadata_schema_length);\n\n/**\n@brief Print out the state of this table to the specified stream.\n\nThis method is intended for debugging purposes and should not be used\nin production code. The format of the output should **not** be depended\non and may change arbitrarily between versions.\n\n@param self A pointer to a tsk_edge_table_t object.\n@param out The stream to write the summary to.\n*/\nvoid tsk_edge_table_print_state(const tsk_edge_table_t *self, FILE *out);\n\n/**\n@brief Replace this table's data by copying from a set of column arrays\n\n@rst\nClears the data columns of this table and then copies column data from the specified\nset of arrays. The supplied arrays should all contain data on the same number of rows.\nThe metadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_edge_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays.\n@param left The array of double left values to be copied.\n@param right The array of double right values to be copied.\n@param parent The array of tsk_id_t parent values to be copied.\n@param child The array of tsk_id_t child values to be copied.\n@param metadata The array of char metadata values to be copied.\n@param metadata_offset The array of tsk_size_t metadata offset values to be copied.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_edge_table_set_columns(tsk_edge_table_t *self, tsk_size_t num_rows,\n const double *left, const double *right, const tsk_id_t *parent,\n const tsk_id_t *child, const char *metadata, const tsk_size_t *metadata_offset);\n\n/**\n@brief Extends this table by copying from a set of column arrays\n\n@rst\nCopies column data from the specified set of arrays to create new rows at the end of the\ntable. The supplied arrays should all contain data on the same number of rows. The\nmetadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_edge_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays.\n@param left The array of double left values to be copied.\n@param right The array of double right values to be copied.\n@param parent The array of tsk_id_t parent values to be copied.\n@param child The array of tsk_id_t child values to be copied.\n@param metadata The array of char metadata values to be copied.\n@param metadata_offset The array of tsk_size_t metadata offset values to be copied.\n*/\nint tsk_edge_table_append_columns(tsk_edge_table_t *self, tsk_size_t num_rows,\n const double *left, const double *right, const tsk_id_t *parent,\n const tsk_id_t *child, const char *metadata, const tsk_size_t *metadata_offset);\n\n/**\n@brief Controls the pre-allocation strategy for this table\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_edge_table_t object.\n@param max_rows_increment The number of rows to pre-allocate, or zero for the default\n doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_edge_table_set_max_rows_increment(\n tsk_edge_table_t *self, tsk_size_t max_rows_increment);\n\n/**\n@brief Controls the pre-allocation strategy for the metadata column\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_edge_table_t object.\n@param max_metadata_length_increment The number of bytes to pre-allocate, or zero for\nthe default doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_edge_table_set_max_metadata_length_increment(\n tsk_edge_table_t *self, tsk_size_t max_metadata_length_increment);\n\n/**\n@brief Squash adjacent edges in-place\n\n@rst\nSorts, then condenses the table into the smallest possible number of rows by\ncombining any adjacent edges. A pair of edges is said to be `adjacent` if\nthey have the same parent and child nodes, and if the left coordinate of\none of the edges is equal to the right coordinate of the other edge.\nThis process is performed in-place so that any set of adjacent edges is\nreplaced by a single edge. The new edge will have the same parent and child\nnode, a left coordinate equal to the smallest left coordinate in the set,\nand a right coordinate equal to the largest right coordinate in the set.\nThe new edge table will be sorted in the canonical order (P, C, L, R).\n\n.. note::\n Note that this method will fail if any edges have non-empty metadata.\n\n@endrst\n\n@param self A pointer to a tsk_edge_table_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_edge_table_squash(tsk_edge_table_t *self);\n\n/** @} */\n\n/* Undocumented methods */\n\nint tsk_edge_table_dump_text(const tsk_edge_table_t *self, FILE *out);\n\n/**\n@defgroup MIGRATION_TABLE_API_GROUP Migration table API.\n@{\n*/\n\n/**\n@brief Initialises the table by allocating the internal memory.\n\n@rst\nThis must be called before any operations are performed on the table.\nSee the :ref:`sec_c_api_overview_structure` for details on how objects\nare initialised and freed.\n@endrst\n\n@param self A pointer to an uninitialised tsk_migration_table_t object.\n@param options Allocation time options. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_migration_table_init(tsk_migration_table_t *self, tsk_flags_t options);\n\n/**\n@brief Free the internal memory for the specified table.\n\n@param self A pointer to an initialised tsk_migration_table_t object.\n@return Always returns 0.\n*/\nint tsk_migration_table_free(tsk_migration_table_t *self);\n\n/**\n@brief Adds a row to this migration table.\n\n@rst\nAdd a new migration with the specified ``left``, ``right``, ``node``,\n``source``, ``dest``, ``time`` and ``metadata`` to the table.\nSee the :ref:`table definition `\nfor details of the columns in this table.\n@endrst\n\n@param self A pointer to a tsk_migration_table_t object.\n@param left The left coordinate for the new migration.\n@param right The right coordinate for the new migration.\n@param node The node ID for the new migration.\n@param source The source population ID for the new migration.\n@param dest The destination population ID for the new migration.\n@param time The time for the new migration.\n@param metadata The metadata to be associated with the new migration. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``metadata_length`` is 0.\n@param metadata_length The size of the metadata array in bytes.\n\n@return Return the ID of the newly added migration on success,\n or a negative value on failure.\n*/\ntsk_id_t tsk_migration_table_add_row(tsk_migration_table_t *self, double left,\n double right, tsk_id_t node, tsk_id_t source, tsk_id_t dest, double time,\n const char *metadata, tsk_size_t metadata_length);\n\n/**\n@brief Updates the row at the specified index.\n\n@rst\nRewrite the row at the specified index in this table to use the specified\nvalues. A copy of the ``metadata`` parameter is taken immediately. See the\n:ref:`table definition ` for details of the columns\nin this table.\n\n.. warning::\n Because of the way that ragged columns are encoded, this method requires a\n full rewrite of the internal column memory in worst case, and would\n therefore be inefficient for bulk updates for such columns. However, if the\n sizes of all ragged column values are unchanged in the updated row, this\n method is guaranteed to only update the memory for the row in question.\n@endrst\n\n@param self A pointer to a tsk_migration_table_t object.\n@param index The row to update.\n@param left The left coordinate for the migration.\n@param right The right coordinate for the migration.\n@param node The node ID for the migration.\n@param source The source population ID for the migration.\n@param dest The destination population ID for the migration.\n@param time The time for the migration.\n@param metadata The metadata to be associated with the migration. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``metadata_length`` is 0.\n@param metadata_length The size of the metadata array in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_migration_table_update_row(tsk_migration_table_t *self, tsk_id_t index,\n double left, double right, tsk_id_t node, tsk_id_t source, tsk_id_t dest,\n double time, const char *metadata, tsk_size_t metadata_length);\n\n/**\n@brief Clears this table, setting the number of rows to zero.\n\n@rst\nNo memory is freed as a result of this operation; please use\n:c:func:`tsk_migration_table_free` to free the table's internal resources. Note that the\nmetadata schema is not cleared.\n@endrst\n\n@param self A pointer to a tsk_migration_table_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_migration_table_clear(tsk_migration_table_t *self);\n\n/**\n@brief Truncates this table so that only the first num_rows are retained.\n\n@param self A pointer to a tsk_migration_table_t object.\n@param num_rows The number of rows to retain in the table.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_migration_table_truncate(tsk_migration_table_t *self, tsk_size_t num_rows);\n\n/**\n@brief Extends this table by appending rows copied from another table.\n\n@rst\nAppends the rows at the specified indexes from the table ``other`` to the end of this\ntable. Row indexes can be repeated and in any order. If ``row_indexes`` is NULL, append\nthe first ``num_rows`` from ``other`` to this table. Note that metadata is copied as-is\nand is not checked for compatibility with any existing schema on this table.\n@endrst\n\n@param self A pointer to a tsk_migration_table_t object where rows are to be added.\n@param other A pointer to a tsk_migration_table_t object where rows are copied from.\n@param num_rows The number of rows from ``other`` to append to this table.\n@param row_indexes Array of row indexes in ``other``. If ``NULL`` is passed then the\n first ``num_rows`` of ``other`` are used.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\n\nint tsk_migration_table_extend(tsk_migration_table_t *self,\n const tsk_migration_table_t *other, tsk_size_t num_rows, const tsk_id_t *row_indexes,\n tsk_flags_t options);\n\n/**\n@brief Subset this table by keeping rows according to a boolean mask.\n\n@rst\nDeletes rows from this table and optionally return the mapping from IDs in\nthe current table to the updated table. Rows are kept or deleted according to\nthe specified boolean array ``keep`` such that for each row ``j`` if\n``keep[j]`` is false (zero) the row is deleted, and otherwise the row is\nretained. Thus, ``keep`` must be an array of at least ``num_rows``\n:c:type:`bool` values.\n\nIf the ``id_map`` argument is non-null, this array will be updated to represent\nthe mapping between IDs before and after row deletion. For row ``j``,\n``id_map[j]`` will contain the new ID for row ``j`` if it is retained, or\n:c:macro:`TSK_NULL` if the row has been removed. Thus, ``id_map`` must be an\narray of at least ``num_rows`` :c:type:`tsk_id_t` values.\n\n.. warning::\n C++ users need to be careful to specify the correct type when\n passing in values for the ``keep`` array,\n using ``std::vector`` and not ``std::vector``,\n as the latter may not be correct size.\n\n@endrst\n\n@param self A pointer to a tsk_migration_table_t object.\n@param keep Array of boolean flags describing whether a particular\n row should be kept or not. Must be at least ``num_rows`` long.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@param id_map An array in which to store the mapping between new\n and old IDs. If NULL, this will be ignored.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_migration_table_keep_rows(tsk_migration_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t options, tsk_id_t *id_map);\n\n/**\n@brief Returns true if the data in the specified table is identical to the data\n in this table.\n\n@rst\n\n**Options**\n\nOptions to control the comparison can be specified by providing one or\nmore of the following bitwise flags. By default (options=0) tables are\nconsidered equal if they are byte-wise identical in all columns,\nand their metadata schemas are byte-wise identical.\n\n- :c:macro:`TSK_CMP_IGNORE_METADATA`\n@endrst\n\n@param self A pointer to a tsk_migration_table_t object.\n@param other A pointer to a tsk_migration_table_t object.\n@param options Bitwise comparison options.\n@return Return true if the specified table is equal to this table.\n*/\nbool tsk_migration_table_equals(const tsk_migration_table_t *self,\n const tsk_migration_table_t *other, tsk_flags_t options);\n\n/**\n@brief Copies the state of this table into the specified destination.\n\n@rst\nBy default the method initialises the specified destination table. If the\ndestination is already initialised, the :c:macro:`TSK_NO_INIT` option should\nbe supplied to avoid leaking memory.\n@endrst\n\n@param self A pointer to a tsk_migration_table_t object.\n@param dest A pointer to a tsk_migration_table_t object. If the TSK_NO_INIT\noption is specified, this must be an initialised migration table. If not, it must be an\nuninitialised migration table.\n@param options Bitwise option flags.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_migration_table_copy(\n const tsk_migration_table_t *self, tsk_migration_table_t *dest, tsk_flags_t options);\n\n/**\n@brief Get the row at the specified index.\n\n@rst\nUpdates the specified migration struct to reflect the values in the specified row.\nPointers to memory within this struct are handled by the table and should **not**\nbe freed by client code. These pointers are guaranteed to be valid until the\nnext operation that modifies the table (e.g., by adding a new row), but not afterwards.\n@endrst\n\n@param self A pointer to a tsk_migration_table_t object.\n@param index The requested table row.\n@param row A pointer to a tsk_migration_t struct that is updated to reflect the\n values in the specified row.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_migration_table_get_row(\n const tsk_migration_table_t *self, tsk_id_t index, tsk_migration_t *row);\n\n/**\n@brief Set the metadata schema\n@rst\nCopies the metadata schema string to this table, replacing any existing.\n@endrst\n@param self A pointer to a tsk_migration_table_t object.\n@param metadata_schema A pointer to a char array.\n@param metadata_schema_length The size of the metadata schema in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_migration_table_set_metadata_schema(tsk_migration_table_t *self,\n const char *metadata_schema, tsk_size_t metadata_schema_length);\n\n/**\n@brief Print out the state of this table to the specified stream.\n\nThis method is intended for debugging purposes and should not be used\nin production code. The format of the output should **not** be depended\non and may change arbitrarily between versions.\n\n@param self A pointer to a tsk_migration_table_t object.\n@param out The stream to write the summary to.\n*/\nvoid tsk_migration_table_print_state(const tsk_migration_table_t *self, FILE *out);\n\n/**\n@brief Replace this table's data by copying from a set of column arrays\n\n@rst\nClears the data columns of this table and then copies column data from the specified\nset of arrays. The supplied arrays should all contain data on the same number of rows.\nThe metadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_migration_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays.\n@param left The array of double left values to be copied.\n@param right The array of double right values to be copied.\n@param node The array of tsk_id_t node values to be copied.\n@param source The array of tsk_id_t source values to be copied.\n@param dest The array of tsk_id_t dest values to be copied.\n@param time The array of double time values to be copied.\n@param metadata The array of char metadata values to be copied.\n@param metadata_offset The array of tsk_size_t metadata offset values to be copied.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_migration_table_set_columns(tsk_migration_table_t *self, tsk_size_t num_rows,\n const double *left, const double *right, const tsk_id_t *node,\n const tsk_id_t *source, const tsk_id_t *dest, const double *time,\n const char *metadata, const tsk_size_t *metadata_offset);\n\n/**\n@brief Extends this table by copying from a set of column arrays\n\n@rst\nCopies column data from the specified set of arrays to create new rows at the end of the\ntable. The supplied arrays should all contain data on the same number of rows. The\nmetadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_migration_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays\n@param left The array of double left values to be copied.\n@param right The array of double right values to be copied.\n@param node The array of tsk_id_t node values to be copied.\n@param source The array of tsk_id_t source values to be copied.\n@param dest The array of tsk_id_t dest values to be copied.\n@param time The array of double time values to be copied.\n@param metadata The array of char metadata values to be copied.\n@param metadata_offset The array of tsk_size_t metadata offset values to be copied.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_migration_table_append_columns(tsk_migration_table_t *self, tsk_size_t num_rows,\n const double *left, const double *right, const tsk_id_t *node,\n const tsk_id_t *source, const tsk_id_t *dest, const double *time,\n const char *metadata, const tsk_size_t *metadata_offset);\n\n/**\n@brief Controls the pre-allocation strategy for this table\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_migration_table_t object.\n@param max_rows_increment The number of rows to pre-allocate, or zero for the default\n doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_migration_table_set_max_rows_increment(\n tsk_migration_table_t *self, tsk_size_t max_rows_increment);\n\n/**\n@brief Controls the pre-allocation strategy for the metadata column\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_migration_table_t object.\n@param max_metadata_length_increment The number of bytes to pre-allocate, or zero for\nthe default doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_migration_table_set_max_metadata_length_increment(\n tsk_migration_table_t *self, tsk_size_t max_metadata_length_increment);\n\n/** @} */\n\n/* Undocumented methods */\n\nint tsk_migration_table_dump_text(const tsk_migration_table_t *self, FILE *out);\n\n/**\n@defgroup SITE_TABLE_API_GROUP Site table API.\n@{\n*/\n\n/**\n@brief Initialises the table by allocating the internal memory.\n\n@rst\nThis must be called before any operations are performed on the table.\nSee the :ref:`sec_c_api_overview_structure` for details on how objects\nare initialised and freed.\n@endrst\n\n@param self A pointer to an uninitialised tsk_site_table_t object.\n@param options Allocation time options. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_site_table_init(tsk_site_table_t *self, tsk_flags_t options);\n\n/**\n@brief Free the internal memory for the specified table.\n\n@param self A pointer to an initialised tsk_site_table_t object.\n@return Always returns 0.\n*/\nint tsk_site_table_free(tsk_site_table_t *self);\n\n/**\n@brief Adds a row to this site table.\n\n@rst\nAdd a new site with the specified ``position``, ``ancestral_state``\nand ``metadata`` to the table. Copies of ``ancestral_state`` and ``metadata``\nare immediately taken. See the :ref:`table definition `\nfor details of the columns in this table.\n@endrst\n\n@param self A pointer to a tsk_site_table_t object.\n@param position The position coordinate for the new site.\n@param ancestral_state The ancestral_state for the new site.\n@param ancestral_state_length The length of the ancestral_state in bytes.\n@param metadata The metadata to be associated with the new site. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``metadata_length`` is 0.\n@param metadata_length The size of the metadata array in bytes.\n@return Return the ID of the newly added site on success,\n or a negative value on failure.\n*/\ntsk_id_t tsk_site_table_add_row(tsk_site_table_t *self, double position,\n const char *ancestral_state, tsk_size_t ancestral_state_length, const char *metadata,\n tsk_size_t metadata_length);\n\n/**\n@brief Updates the row at the specified index.\n\n@rst\nRewrite the row at the specified index in this table to use the specified\nvalues. Copies of the ``ancestral_state`` and ``metadata`` parameters are taken\nimmediately. See the :ref:`table definition ` for\ndetails of the columns in this table.\n\n.. warning::\n Because of the way that ragged columns are encoded, this method requires a\n full rewrite of the internal column memory in worst case, and would\n therefore be inefficient for bulk updates for such columns. However, if the\n sizes of all ragged column values are unchanged in the updated row, this\n method is guaranteed to only update the memory for the row in question.\n@endrst\n\n@param self A pointer to a tsk_site_table_t object.\n@param index The row to update.\n@param position The position coordinate for the site.\n@param ancestral_state The ancestral_state for the site.\n@param ancestral_state_length The length of the ancestral_state in bytes.\n@param metadata The metadata to be associated with the site. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``metadata_length`` is 0.\n@param metadata_length The size of the metadata array in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_site_table_update_row(tsk_site_table_t *self, tsk_id_t index, double position,\n const char *ancestral_state, tsk_size_t ancestral_state_length, const char *metadata,\n tsk_size_t metadata_length);\n\n/**\n@brief Clears this table, setting the number of rows to zero.\n\n@rst\nNo memory is freed as a result of this operation; please use\n:c:func:`tsk_site_table_free` to free the table's internal resources. Note that the\nmetadata schema is not cleared.\n@endrst\n\n@param self A pointer to a tsk_site_table_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_site_table_clear(tsk_site_table_t *self);\n\n/**\n@brief Truncates this table so that only the first num_rows are retained.\n\n@param self A pointer to a tsk_site_table_t object.\n@param num_rows The number of rows to retain in the table.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_site_table_truncate(tsk_site_table_t *self, tsk_size_t num_rows);\n\n/**\n@brief Extends this table by appending rows copied from another table.\n\n@rst\nAppends the rows at the specified indexes from the table ``other`` to the end of this\ntable. Row indexes can be repeated and in any order. If ``row_indexes`` is NULL, append\nthe first ``num_rows`` from ``other`` to this table. Note that metadata is copied as-is\nand is not checked for compatibility with any existing schema on this table.\n@endrst\n\n@param self A pointer to a tsk_site_table_t object where rows are to be added.\n@param other A pointer to a tsk_site_table_t object where rows are copied from.\n@param num_rows The number of rows from ``other`` to append to this table.\n@param row_indexes Array of row indexes in ``other``. If ``NULL`` is passed then the\n first ``num_rows`` of ``other`` are used.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_site_table_extend(tsk_site_table_t *self, const tsk_site_table_t *other,\n tsk_size_t num_rows, const tsk_id_t *row_indexes, tsk_flags_t options);\n\n/**\n@brief Subset this table by keeping rows according to a boolean mask.\n\n@rst\nDeletes rows from this table and optionally return the mapping from IDs in\nthe current table to the updated table. Rows are kept or deleted according to\nthe specified boolean array ``keep`` such that for each row ``j`` if\n``keep[j]`` is false (zero) the row is deleted, and otherwise the row is\nretained. Thus, ``keep`` must be an array of at least ``num_rows``\n:c:type:`bool` values.\n\nIf the ``id_map`` argument is non-null, this array will be updated to represent\nthe mapping between IDs before and after row deletion. For row ``j``,\n``id_map[j]`` will contain the new ID for row ``j`` if it is retained, or\n:c:macro:`TSK_NULL` if the row has been removed. Thus, ``id_map`` must be an\narray of at least ``num_rows`` :c:type:`tsk_id_t` values.\n\n.. warning::\n C++ users need to be careful to specify the correct type when\n passing in values for the ``keep`` array,\n using ``std::vector`` and not ``std::vector``,\n as the latter may not be correct size.\n\n@endrst\n\n@param self A pointer to a tsk_site_table_t object.\n@param keep Array of boolean flags describing whether a particular\n row should be kept or not. Must be at least ``num_rows`` long.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@param id_map An array in which to store the mapping between new\n and old IDs. If NULL, this will be ignored.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_site_table_keep_rows(tsk_site_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t options, tsk_id_t *id_map);\n\n/**\n@brief Returns true if the data in the specified table is identical to the data\n in this table.\n\n@rst\n\n**Options**\n\nOptions to control the comparison can be specified by providing one or\nmore of the following bitwise flags. By default (options=0) tables are\nconsidered equal if they are byte-wise identical in all columns,\nand their metadata schemas are byte-wise identical.\n\n- :c:macro:`TSK_CMP_IGNORE_METADATA`\n@endrst\n\n@param self A pointer to a tsk_site_table_t object.\n@param other A pointer to a tsk_site_table_t object.\n@param options Bitwise comparison options.\n@return Return true if the specified table is equal to this table.\n*/\nbool tsk_site_table_equals(\n const tsk_site_table_t *self, const tsk_site_table_t *other, tsk_flags_t options);\n\n/**\n@brief Copies the state of this table into the specified destination.\n\n@rst\nBy default the method initialises the specified destination table. If the\ndestination is already initialised, the :c:macro:`TSK_NO_INIT` option should\nbe supplied to avoid leaking memory.\n@endrst\n\n@param self A pointer to a tsk_site_table_t object.\n@param dest A pointer to a tsk_site_table_t object. If the TSK_NO_INIT option\n is specified, this must be an initialised site table. If not, it must\n be an uninitialised site table.\n@param options Bitwise option flags.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_site_table_copy(\n const tsk_site_table_t *self, tsk_site_table_t *dest, tsk_flags_t options);\n\n/**\n@brief Get the row at the specified index.\n\n@rst\nUpdates the specified site struct to reflect the values in the specified row.\n\nThis function always sets the ``mutations`` and ``mutations_length``\nfields in the parameter :c:struct:`tsk_site_t` to ``NULL`` and ``0`` respectively.\nTo get access to the mutations for a particular site, please use the\ntree sequence method, :c:func:`tsk_treeseq_get_site`.\n\nPointers to memory within this struct are handled by the table and should **not**\nbe freed by client code. These pointers are guaranteed to be valid until the\nnext operation that modifies the table (e.g., by adding a new row), but not afterwards.\n@endrst\n\n@param self A pointer to a tsk_site_table_t object.\n@param index The requested table row.\n@param row A pointer to a tsk_site_t struct that is updated to reflect the\n values in the specified row.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_site_table_get_row(\n const tsk_site_table_t *self, tsk_id_t index, tsk_site_t *row);\n\n/**\n@brief Set the metadata schema\n@rst\nCopies the metadata schema string to this table, replacing any existing.\n@endrst\n@param self A pointer to a tsk_site_table_t object.\n@param metadata_schema A pointer to a char array.\n@param metadata_schema_length The size of the metadata schema in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_site_table_set_metadata_schema(tsk_site_table_t *self,\n const char *metadata_schema, tsk_size_t metadata_schema_length);\n\n/**\n@brief Print out the state of this table to the specified stream.\n\nThis method is intended for debugging purposes and should not be used\nin production code. The format of the output should **not** be depended\non and may change arbitrarily between versions.\n\n@param self A pointer to a tsk_site_table_t object.\n@param out The stream to write the summary to.\n*/\nvoid tsk_site_table_print_state(const tsk_site_table_t *self, FILE *out);\n\n/**\n@brief Replace this table's data by copying from a set of column arrays\n\n@rst\nClears the data columns of this table and then copies column data from the specified\nset of arrays. The supplied arrays should all contain data on the same number of rows.\nThe metadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_site_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays.\n@param position The array of double position values to be copied.\n@param ancestral_state The array of char ancestral state values to be copied.\n@param ancestral_state_offset The array of tsk_size_t ancestral state offset values to be\n copied.\n@param metadata The array of char metadata values to be copied.\n@param metadata_offset The array of tsk_size_t metadata offset values to be copied.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_site_table_set_columns(tsk_site_table_t *self, tsk_size_t num_rows,\n const double *position, const char *ancestral_state,\n const tsk_size_t *ancestral_state_offset, const char *metadata,\n const tsk_size_t *metadata_offset);\n\n/**\n@brief Extends this table by copying from a set of column arrays\n\n@rst\nCopies column data from the specified set of arrays to create new rows at the end of the\ntable. The supplied arrays should all contain data on the same number of rows. The\nmetadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_site_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays.\n@param position The array of double position values to be copied.\n@param ancestral_state The array of char ancestral state values to be copied.\n@param ancestral_state_offset The array of tsk_size_t ancestral state offset values to be\n copied.\n@param metadata The array of char metadata values to be copied.\n@param metadata_offset The array of tsk_size_t metadata offset values to be copied.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_site_table_append_columns(tsk_site_table_t *self, tsk_size_t num_rows,\n const double *position, const char *ancestral_state,\n const tsk_size_t *ancestral_state_offset, const char *metadata,\n const tsk_size_t *metadata_offset);\n\n/**\n@brief Controls the pre-allocation strategy for this table\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_site_table_t object.\n@param max_rows_increment The number of rows to pre-allocate, or zero for the default\n doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_site_table_set_max_rows_increment(\n tsk_site_table_t *self, tsk_size_t max_rows_increment);\n\n/**\n@brief Controls the pre-allocation strategy for the metadata column\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_site_table_t object.\n@param max_metadata_length_increment The number of bytes to pre-allocate, or zero for\nthe default doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\n\nint tsk_site_table_set_max_metadata_length_increment(\n tsk_site_table_t *self, tsk_size_t max_metadata_length_increment);\n\n/**\n@brief Controls the pre-allocation strategy for the ancestral_state column\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_site_table_t object.\n@param max_ancestral_state_length_increment The number of bytes to pre-allocate, or zero\nfor the default doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_site_table_set_max_ancestral_state_length_increment(\n tsk_site_table_t *self, tsk_size_t max_ancestral_state_length_increment);\n\n/** @} */\n\n/* Undocumented methods */\n\nint tsk_site_table_dump_text(const tsk_site_table_t *self, FILE *out);\n\n/**\n@defgroup MUTATION_TABLE_API_GROUP Mutation table API.\n@{\n*/\n\n/**\n@brief Initialises the table by allocating the internal memory.\n\n@rst\nThis must be called before any operations are performed on the table.\nSee the :ref:`sec_c_api_overview_structure` for details on how objects\nare initialised and freed.\n@endrst\n\n@param self A pointer to an uninitialised tsk_mutation_table_t object.\n@param options Allocation time options. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_mutation_table_init(tsk_mutation_table_t *self, tsk_flags_t options);\n\n/**\n@brief Free the internal memory for the specified table.\n\n@param self A pointer to an initialised tsk_mutation_table_t object.\n@return Always returns 0.\n*/\nint tsk_mutation_table_free(tsk_mutation_table_t *self);\n\n/**\n@brief Adds a row to this mutation table.\n\n@rst\nAdd a new mutation with the specified ``site``, ``parent``, ``derived_state``\nand ``metadata`` to the table. Copies of ``derived_state`` and ``metadata``\nare immediately taken. See the :ref:`table definition `\nfor details of the columns in this table.\n@endrst\n\n@param self A pointer to a tsk_mutation_table_t object.\n@param site The site ID for the new mutation.\n@param node The ID of the node this mutation occurs over.\n@param parent The ID of the parent mutation.\n@param time The time of the mutation.\n@param derived_state The derived_state for the new mutation.\n@param derived_state_length The length of the derived_state in bytes.\n@param metadata The metadata to be associated with the new mutation. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``metadata_length`` is 0.\n@param metadata_length The size of the metadata array in bytes.\n@return Return the ID of the newly added mutation on success,\n or a negative value on failure.\n*/\ntsk_id_t tsk_mutation_table_add_row(tsk_mutation_table_t *self, tsk_id_t site,\n tsk_id_t node, tsk_id_t parent, double time, const char *derived_state,\n tsk_size_t derived_state_length, const char *metadata, tsk_size_t metadata_length);\n\n/**\n@brief Updates the row at the specified index.\n\n@rst\nRewrite the row at the specified index in this table to use the specified\nvalues. Copies of the ``derived_state`` and ``metadata`` parameters are taken\nimmediately. See the :ref:`table definition ` for\ndetails of the columns in this table.\n\n.. warning::\n Because of the way that ragged columns are encoded, this method requires a\n full rewrite of the internal column memory in worst case, and would\n therefore be inefficient for bulk updates for such columns. However, if the\n sizes of all ragged column values are unchanged in the updated row, this\n method is guaranteed to only update the memory for the row in question.\n@endrst\n\n@param self A pointer to a tsk_mutation_table_t object.\n@param index The row to update.\n@param site The site ID for the mutation.\n@param node The ID of the node this mutation occurs over.\n@param parent The ID of the parent mutation.\n@param time The time of the mutation.\n@param derived_state The derived_state for the mutation.\n@param derived_state_length The length of the derived_state in bytes.\n@param metadata The metadata to be associated with the mutation. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``metadata_length`` is 0.\n@param metadata_length The size of the metadata array in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_mutation_table_update_row(tsk_mutation_table_t *self, tsk_id_t index,\n tsk_id_t site, tsk_id_t node, tsk_id_t parent, double time,\n const char *derived_state, tsk_size_t derived_state_length, const char *metadata,\n tsk_size_t metadata_length);\n\n/**\n@brief Clears this table, setting the number of rows to zero.\n\n@rst\nNo memory is freed as a result of this operation; please use\n:c:func:`tsk_mutation_table_free` to free the table's internal resources. Note that the\nmetadata schema is not cleared.\n@endrst\n\n@param self A pointer to a tsk_mutation_table_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_mutation_table_clear(tsk_mutation_table_t *self);\n\n/**\n@brief Truncates this table so that only the first num_rows are retained.\n\n@param self A pointer to a tsk_mutation_table_t object.\n@param num_rows The number of rows to retain in the table.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_mutation_table_truncate(tsk_mutation_table_t *self, tsk_size_t num_rows);\n\n/**\n@brief Extends this table by appending rows copied from another table.\n\n@rst\nAppends the rows at the specified indexes from the table ``other`` to the end of this\ntable. Row indexes can be repeated and in any order. If ``row_indexes`` is NULL, append\nthe first ``num_rows`` from ``other`` to this table. Note that metadata is copied as-is\nand is not checked for compatibility with any existing schema on this table.\n@endrst\n\n@param self A pointer to a tsk_mutation_table_t object where rows are to be added.\n@param other A pointer to a tsk_mutation_table_t object where rows are copied from.\n@param num_rows The number of rows from ``other`` to append to this table.\n@param row_indexes Array of row indexes in ``other``. If ``NULL`` is passed then the\n first ``num_rows`` of ``other`` are used.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_mutation_table_extend(tsk_mutation_table_t *self,\n const tsk_mutation_table_t *other, tsk_size_t num_rows, const tsk_id_t *row_indexes,\n tsk_flags_t options);\n\n/**\n@brief Subset this table by keeping rows according to a boolean mask.\n\n@rst\nDeletes rows from this table and optionally return the mapping from IDs in\nthe current table to the updated table. Rows are kept or deleted according to\nthe specified boolean array ``keep`` such that for each row ``j`` if\n``keep[j]`` is false (zero) the row is deleted, and otherwise the row is\nretained. Thus, ``keep`` must be an array of at least ``num_rows``\n:c:type:`bool` values.\n\nIf the ``id_map`` argument is non-null, this array will be updated to represent\nthe mapping between IDs before and after row deletion. For row ``j``,\n``id_map[j]`` will contain the new ID for row ``j`` if it is retained, or\n:c:macro:`TSK_NULL` if the row has been removed. Thus, ``id_map`` must be an\narray of at least ``num_rows`` :c:type:`tsk_id_t` values.\n\nThe values in the ``parent`` column are updated according to this map, so that\nreference integrity within the table is maintained. As a consequence of this,\nthe values in the ``parent`` column for kept rows are bounds-checked and an\nerror raised if they are not valid. Rows that are deleted are not checked for\nparent ID integrity.\n\nIf an attempt is made to delete rows that are referred to by the ``parent``\ncolumn of rows that are retained, an error is raised.\n\nThese error conditions are checked before any alterations to the table are\nmade.\n\n.. warning::\n C++ users need to be careful to specify the correct type when\n passing in values for the ``keep`` array,\n using ``std::vector`` and not ``std::vector``,\n as the latter may not be correct size.\n\n@endrst\n\n@param self A pointer to a tsk_mutation_table_t object.\n@param keep Array of boolean flags describing whether a particular\n row should be kept or not. Must be at least ``num_rows`` long.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@param id_map An array in which to store the mapping between new\n and old IDs. If NULL, this will be ignored.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_mutation_table_keep_rows(tsk_mutation_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t options, tsk_id_t *id_map);\n\n/**\n@brief Returns true if the data in the specified table is identical to the data\n in this table.\n\n@rst\n\n**Options**\n\nOptions to control the comparison can be specified by providing one or\nmore of the following bitwise flags. By default (options=0) tables are\nconsidered equal if they are byte-wise identical in all columns,\nand their metadata schemas are byte-wise identical.\n\n- :c:macro:`TSK_CMP_IGNORE_METADATA`\n@endrst\n\n@param self A pointer to a tsk_mutation_table_t object.\n@param other A pointer to a tsk_mutation_table_t object.\n@param options Bitwise comparison options.\n@return Return true if the specified table is equal to this table.\n*/\nbool tsk_mutation_table_equals(const tsk_mutation_table_t *self,\n const tsk_mutation_table_t *other, tsk_flags_t options);\n\n/**\n@brief Copies the state of this table into the specified destination.\n\n@rst\nBy default the method initialises the specified destination table. If the\ndestination is already initialised, the :c:macro:`TSK_NO_INIT` option should\nbe supplied to avoid leaking memory.\n@endrst\n\n@param self A pointer to a tsk_mutation_table_t object.\n@param dest A pointer to a tsk_mutation_table_t object. If the TSK_NO_INIT\noption is specified, this must be an initialised mutation table. If not, it must be an\nuninitialised mutation table.\n@param options Bitwise option flags.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_mutation_table_copy(\n const tsk_mutation_table_t *self, tsk_mutation_table_t *dest, tsk_flags_t options);\n\n/**\n@brief Get the row at the specified index.\n\n@rst\nUpdates the specified mutation struct to reflect the values in the specified row.\n\nThis function always sets the ``edge`` field in parameter\n:c:struct:`tsk_mutation_t` to ``TSK_NULL``. To determine the ID of\nthe edge associated with a particular mutation, please use the\ntree sequence method, :c:func:`tsk_treeseq_get_mutation`.\n\nPointers to memory within this struct are handled by the table and should **not**\nbe freed by client code. These pointers are guaranteed to be valid until the\nnext operation that modifies the table (e.g., by adding a new row), but not afterwards.\n@endrst\n\n@param self A pointer to a tsk_mutation_table_t object.\n@param index The requested table row.\n@param row A pointer to a tsk_mutation_t struct that is updated to reflect the\n values in the specified row.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_mutation_table_get_row(\n const tsk_mutation_table_t *self, tsk_id_t index, tsk_mutation_t *row);\n\n/**\n@brief Set the metadata schema\n@rst\nCopies the metadata schema string to this table, replacing any existing.\n@endrst\n@param self A pointer to a tsk_mutation_table_t object.\n@param metadata_schema A pointer to a char array.\n@param metadata_schema_length The size of the metadata schema in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_mutation_table_set_metadata_schema(tsk_mutation_table_t *self,\n const char *metadata_schema, tsk_size_t metadata_schema_length);\n\n/**\n@brief Print out the state of this table to the specified stream.\n\nThis method is intended for debugging purposes and should not be used\nin production code. The format of the output should **not** be depended\non and may change arbitrarily between versions.\n\n@param self A pointer to a tsk_mutation_table_t object.\n@param out The stream to write the summary to.\n*/\nvoid tsk_mutation_table_print_state(const tsk_mutation_table_t *self, FILE *out);\n\n/**\n@brief Replace this table's data by copying from a set of column arrays\n\n@rst\nClears the data columns of this table and then copies column data from the specified\nset of arrays. The supplied arrays should all contain data on the same number of rows.\nThe metadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_mutation_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays.\n@param site The array of tsk_id_t site values to be copied.\n@param node The array of tsk_id_t node values to be copied.\n@param parent The array of tsk_id_t parent values to be copied.\n@param time The array of double time values to be copied.\n@param derived_state The array of char derived_state values to be copied.\n@param derived_state_offset The array of tsk_size_t derived state offset values to be\ncopied.\n@param metadata The array of char metadata values to be copied.\n@param metadata_offset The array of tsk_size_t metadata offset values to be copied.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_mutation_table_set_columns(tsk_mutation_table_t *self, tsk_size_t num_rows,\n const tsk_id_t *site, const tsk_id_t *node, const tsk_id_t *parent,\n const double *time, const char *derived_state,\n const tsk_size_t *derived_state_offset, const char *metadata,\n const tsk_size_t *metadata_offset);\n\n/**\n@brief Extends this table by copying from a set of column arrays\n\n@rst\nCopies column data from the specified set of arrays to create new rows at the end of the\ntable. The supplied arrays should all contain data on the same number of rows. The\nmetadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_mutation_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays.\n@param site The array of tsk_id_t site values to be copied.\n@param node The array of tsk_id_t node values to be copied.\n@param parent The array of tsk_id_t parent values to be copied.\n@param time The array of double time values to be copied.\n@param derived_state The array of char derived_state values to be copied.\n@param derived_state_offset The array of tsk_size_t derived state offset values to be\n copied.\n@param metadata The array of char metadata values to be copied.\n@param metadata_offset The array of tsk_size_t metadata offset values to be copied.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_mutation_table_append_columns(tsk_mutation_table_t *self, tsk_size_t num_rows,\n const tsk_id_t *site, const tsk_id_t *node, const tsk_id_t *parent,\n const double *time, const char *derived_state,\n const tsk_size_t *derived_state_offset, const char *metadata,\n const tsk_size_t *metadata_offset);\n\n/**\n@brief Controls the pre-allocation strategy for this table\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_mutation_table_t object.\n@param max_rows_increment The number of rows to pre-allocate, or zero for the default\n doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_mutation_table_set_max_rows_increment(\n tsk_mutation_table_t *self, tsk_size_t max_rows_increment);\n\n/**\n@brief Controls the pre-allocation strategy for the metadata column\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_mutation_table_t object.\n@param max_metadata_length_increment The number of bytes to pre-allocate, or zero for\nthe default doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_mutation_table_set_max_metadata_length_increment(\n tsk_mutation_table_t *self, tsk_size_t max_metadata_length_increment);\n\n/**\n@brief Controls the pre-allocation strategy for the derived_state column\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_mutation_table_t object.\n@param max_derived_state_length_increment The number of bytes to pre-allocate, or zero\nfor the default doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_mutation_table_set_max_derived_state_length_increment(\n tsk_mutation_table_t *self, tsk_size_t max_derived_state_length_increment);\n\n/** @} */\n\n/* Undocumented methods */\n\nint tsk_mutation_table_dump_text(const tsk_mutation_table_t *self, FILE *out);\n\n/**\n@defgroup POPULATION_TABLE_API_GROUP Population table API.\n@{\n*/\n\n/**\n@brief Initialises the table by allocating the internal memory.\n\n@rst\nThis must be called before any operations are performed on the table.\nSee the :ref:`sec_c_api_overview_structure` for details on how objects\nare initialised and freed.\n@endrst\n\n@param self A pointer to an uninitialised tsk_population_table_t object.\n@param options Allocation time options. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_population_table_init(tsk_population_table_t *self, tsk_flags_t options);\n\n/**\n@brief Free the internal memory for the specified table.\n\n@param self A pointer to an initialised tsk_population_table_t object.\n@return Always returns 0.\n*/\nint tsk_population_table_free(tsk_population_table_t *self);\n\n/**\n@brief Adds a row to this population table.\n\n@rst\nAdd a new population with the specified ``metadata`` to the table. A copy of the\n``metadata`` is immediately taken. See the :ref:`table definition\n` for details of the columns in this table.\n@endrst\n\n@param self A pointer to a tsk_population_table_t object.\n@param metadata The metadata to be associated with the new population. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``metadata_length`` is 0.\n@param metadata_length The size of the metadata array in bytes.\n@return Return the ID of the newly added population on success,\n or a negative value on failure.\n*/\ntsk_id_t tsk_population_table_add_row(\n tsk_population_table_t *self, const char *metadata, tsk_size_t metadata_length);\n\n/**\n@brief Updates the row at the specified index.\n\n@rst\nRewrite the row at the specified index in this table to use the specified\nvalues. A copy of the ``metadata`` parameter is taken immediately. See the\n:ref:`table definition ` for details of the\ncolumns in this table.\n\n.. warning::\n Because of the way that ragged columns are encoded, this method requires a\n full rewrite of the internal column memory in worst case, and would\n therefore be inefficient for bulk updates for such columns. However, if the\n sizes of all ragged column values are unchanged in the updated row, this\n method is guaranteed to only update the memory for the row in question.\n@endrst\n\n@param self A pointer to a tsk_population_table_t object.\n@param index The row to update.\n@param metadata The metadata to be associated with the population. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``metadata_length`` is 0.\n@param metadata_length The size of the metadata array in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_population_table_update_row(tsk_population_table_t *self, tsk_id_t index,\n const char *metadata, tsk_size_t metadata_length);\n\n/**\n@brief Clears this table, setting the number of rows to zero.\n\n@rst\nNo memory is freed as a result of this operation; please use\n:c:func:`tsk_population_table_free` to free the table's internal resources. Note that the\nmetadata schema is not cleared.\n@endrst\n\n@param self A pointer to a tsk_population_table_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_population_table_clear(tsk_population_table_t *self);\n\n/**\n@brief Truncates this table so that only the first num_rows are retained.\n\n@param self A pointer to a tsk_population_table_t object.\n@param num_rows The number of rows to retain in the table.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_population_table_truncate(tsk_population_table_t *self, tsk_size_t num_rows);\n\n/**\n@brief Extends this table by appending rows copied from another table.\n\n@rst\nAppends the rows at the specified indexes from the table ``other`` to the end of this\ntable. Row indexes can be repeated and in any order. If ``row_indexes`` is NULL, append\nthe first ``num_rows`` from ``other`` to this table. Note that metadata is copied as-is\nand is not checked for compatibility with any existing schema on this table.\n@endrst\n\n@param self A pointer to a tsk_population_table_t object where rows are to be added.\n@param other A pointer to a tsk_population_table_t object where rows are copied from.\n@param num_rows The number of rows from ``other`` to append to this table.\n@param row_indexes Array of row indexes in ``other``. If ``NULL`` is passed then the\n first ``num_rows`` of ``other`` are used.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_population_table_extend(tsk_population_table_t *self,\n const tsk_population_table_t *other, tsk_size_t num_rows,\n const tsk_id_t *row_indexes, tsk_flags_t options);\n\n/**\n@brief Subset this table by keeping rows according to a boolean mask.\n\n@rst\nDeletes rows from this table and optionally return the mapping from IDs in\nthe current table to the updated table. Rows are kept or deleted according to\nthe specified boolean array ``keep`` such that for each row ``j`` if\n``keep[j]`` is false (zero) the row is deleted, and otherwise the row is\nretained. Thus, ``keep`` must be an array of at least ``num_rows``\n:c:type:`bool` values.\n\nIf the ``id_map`` argument is non-null, this array will be updated to represent\nthe mapping between IDs before and after row deletion. For row ``j``,\n``id_map[j]`` will contain the new ID for row ``j`` if it is retained, or\n:c:macro:`TSK_NULL` if the row has been removed. Thus, ``id_map`` must be an\narray of at least ``num_rows`` :c:type:`tsk_id_t` values.\n\n.. warning::\n C++ users need to be careful to specify the correct type when\n passing in values for the ``keep`` array,\n using ``std::vector`` and not ``std::vector``,\n as the latter may not be correct size.\n\n@endrst\n\n@param self A pointer to a tsk_population_table_t object.\n@param keep Array of boolean flags describing whether a particular\n row should be kept or not. Must be at least ``num_rows`` long.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@param id_map An array in which to store the mapping between new\n and old IDs. If NULL, this will be ignored.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_population_table_keep_rows(tsk_population_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t options, tsk_id_t *id_map);\n\n/**\n@brief Returns true if the data in the specified table is identical to the data\n in this table.\n\n@rst\n\n**Options**\n\nOptions to control the comparison can be specified by providing one or\nmore of the following bitwise flags. By default (options=0) tables are\nconsidered equal if they are byte-wise identical in all columns,\nand their metadata schemas are byte-wise identical.\n\n- :c:macro:`TSK_CMP_IGNORE_METADATA`\n Do not include metadata in the comparison. Note that as metadata is the\n only column in the population table, two population tables are considered\n equal if they have the same number of rows if this flag is specified.\n@endrst\n\n@param self A pointer to a tsk_population_table_t object.\n@param other A pointer to a tsk_population_table_t object.\n@param options Bitwise comparison options.\n@return Return true if the specified table is equal to this table.\n*/\nbool tsk_population_table_equals(const tsk_population_table_t *self,\n const tsk_population_table_t *other, tsk_flags_t options);\n\n/**\n@brief Copies the state of this table into the specified destination.\n\n@rst\nBy default the method initialises the specified destination table. If the\ndestination is already initialised, the :c:macro:`TSK_NO_INIT` option should\nbe supplied to avoid leaking memory.\n@endrst\n\n@param self A pointer to a tsk_population_table_t object.\n@param dest A pointer to a tsk_population_table_t object. If the TSK_NO_INIT\noption is specified, this must be an initialised population table. If not, it must be an\nuninitialised population table.\n@param options Bitwise option flags.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_population_table_copy(const tsk_population_table_t *self,\n tsk_population_table_t *dest, tsk_flags_t options);\n\n/**\n@brief Get the row at the specified index.\n\n@rst\nUpdates the specified population struct to reflect the values in the specified row.\nPointers to memory within this struct are handled by the table and should **not**\nbe freed by client code. These pointers are guaranteed to be valid until the\nnext operation that modifies the table (e.g., by adding a new row), but not afterwards.\n@endrst\n\n@param self A pointer to a tsk_population_table_t object.\n@param index The requested table row.\n@param row A pointer to a tsk_population_t struct that is updated to reflect the\n values in the specified row.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_population_table_get_row(\n const tsk_population_table_t *self, tsk_id_t index, tsk_population_t *row);\n\n/**\n@brief Set the metadata schema\n@rst\nCopies the metadata schema string to this table, replacing any existing.\n@endrst\n@param self A pointer to a tsk_population_table_t object.\n@param metadata_schema A pointer to a char array.\n@param metadata_schema_length The size of the metadata schema in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_population_table_set_metadata_schema(tsk_population_table_t *self,\n const char *metadata_schema, tsk_size_t metadata_schema_length);\n\n/**\n@brief Print out the state of this table to the specified stream.\n\nThis method is intended for debugging purposes and should not be used\nin production code. The format of the output should **not** be depended\non and may change arbitrarily between versions.\n\n@param self A pointer to a tsk_population_table_t object.\n@param out The stream to write the summary to.\n*/\nvoid tsk_population_table_print_state(const tsk_population_table_t *self, FILE *out);\n\n/**\n@brief Replace this table's data by copying from a set of column arrays\n\n@rst\nClears the data columns of this table and then copies column data from the specified\nset of arrays. The supplied arrays should all contain data on the same number of rows.\nThe metadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_population_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays.\n@param metadata The array of char metadata values to be copied.\n@param metadata_offset The array of tsk_size_t metadata offset values to be copied.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_population_table_set_columns(tsk_population_table_t *self, tsk_size_t num_rows,\n const char *metadata, const tsk_size_t *metadata_offset);\n\n/**\n@brief Extends this table by copying from a set of column arrays\n\n@rst\nCopies column data from the specified set of arrays to create new rows at the end of the\ntable. The supplied arrays should all contain data on the same number of rows. The\nmetadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_population_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays.\n@param metadata The array of char metadata values to be copied.\n@param metadata_offset The array of tsk_size_t metadata offset values to be copied.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_population_table_append_columns(tsk_population_table_t *self,\n tsk_size_t num_rows, const char *metadata, const tsk_size_t *metadata_offset);\n\n/**\n@brief Controls the pre-allocation strategy for this table\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_population_table_t object.\n@param max_rows_increment The number of rows to pre-allocate, or zero for the default\n doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_population_table_set_max_rows_increment(\n tsk_population_table_t *self, tsk_size_t max_rows_increment);\n\n/**\n@brief Controls the pre-allocation strategy for the metadata column\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_population_table_t object.\n@param max_metadata_length_increment The number of bytes to pre-allocate, or zero for\nthe default doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_population_table_set_max_metadata_length_increment(\n tsk_population_table_t *self, tsk_size_t max_metadata_length_increment);\n\n/** @} */\n\n/* Undocumented methods */\n\nint tsk_population_table_dump_text(const tsk_population_table_t *self, FILE *out);\n\n/**\n@defgroup PROVENANCE_TABLE_API_GROUP Provenance table API.\n@{\n*/\n\n/**\n@brief Initialises the table by allocating the internal memory.\n\n@rst\nThis must be called before any operations are performed on the table.\nSee the :ref:`sec_c_api_overview_structure` for details on how objects\nare initialised and freed.\n@endrst\n\n@param self A pointer to an uninitialised tsk_provenance_table_t object.\n@param options Allocation time options. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_provenance_table_init(tsk_provenance_table_t *self, tsk_flags_t options);\n\n/**\n@brief Free the internal memory for the specified table.\n\n@param self A pointer to an initialised tsk_provenance_table_t object.\n@return Always returns 0.\n*/\nint tsk_provenance_table_free(tsk_provenance_table_t *self);\n\n/**\n@brief Adds a row to this provenance table.\n\n@rst\nAdd a new provenance with the specified ``timestamp`` and ``record`` to the table.\nCopies of the ``timestamp`` and ``record`` are immediately taken.\nSee the :ref:`table definition `\nfor details of the columns in this table.\n@endrst\n\n@param self A pointer to a tsk_provenance_table_t object.\n@param timestamp The timestamp to be associated with the new provenance. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``timestamp_length`` is 0.\n@param timestamp_length The size of the timestamp array in bytes.\n@param record The record to be associated with the new provenance. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``record_length`` is 0.\n@param record_length The size of the record array in bytes.\n@return Return the ID of the newly added provenance on success,\n or a negative value on failure.\n*/\ntsk_id_t tsk_provenance_table_add_row(tsk_provenance_table_t *self,\n const char *timestamp, tsk_size_t timestamp_length, const char *record,\n tsk_size_t record_length);\n\n/**\n@brief Updates the row at the specified index.\n\n@rst\nRewrite the row at the specified index in this table to use the specified\nvalues. Copies of the ``timestamp`` and ``record`` parameters are taken\nimmediately. See the :ref:`table definition `\nfor details of the columns in this table.\n\n.. warning::\n Because of the way that ragged columns are encoded, this method requires a\n full rewrite of the internal column memory in worst case, and would\n therefore be inefficient for bulk updates for such columns. However, if the\n sizes of all ragged column values are unchanged in the updated row, this\n method is guaranteed to only update the memory for the row in question.\n@endrst\n\n@param self A pointer to a tsk_provenance_table_t object.\n@param index The row to update.\n@param timestamp The timestamp to be associated with new provenance. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``timestamp_length`` is 0.\n@param timestamp_length The size of the timestamp array in bytes.\n@param record The record to be associated with the provenance. This\n is a pointer to arbitrary memory. Can be ``NULL`` if ``record_length`` is 0.\n@param record_length The size of the record array in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_provenance_table_update_row(tsk_provenance_table_t *self, tsk_id_t index,\n const char *timestamp, tsk_size_t timestamp_length, const char *record,\n tsk_size_t record_length);\n\n/**\n@brief Clears this table, setting the number of rows to zero.\n\n@rst\nNo memory is freed as a result of this operation; please use\n:c:func:`tsk_provenance_table_free` to free the table's internal resources.\n@endrst\n\n@param self A pointer to a tsk_provenance_table_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_provenance_table_clear(tsk_provenance_table_t *self);\n\n/**\n@brief Truncates this table so that only the first num_rows are retained.\n\n@param self A pointer to a tsk_provenance_table_t object.\n@param num_rows The number of rows to retain in the table.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_provenance_table_truncate(tsk_provenance_table_t *self, tsk_size_t num_rows);\n\n/**\n@brief Extends this table by appending rows copied from another table.\n\n@rst\nAppends the rows at the specified indexes from the table ``other`` to the end of this\ntable. Row indexes can be repeated and in any order. If ``row_indexes`` is NULL, append\nthe first ``num_rows`` from ``other`` to this table.\n@endrst\n\n@param self A pointer to a tsk_provenance_table_t object where rows are to be added.\n@param other A pointer to a tsk_provenance_table_t object where rows are copied from.\n@param num_rows The number of rows from ``other`` to append to this table.\n@param row_indexes Array of row indexes in ``other``. If ``NULL`` is passed then the\n first ``num_rows`` of ``other`` are used.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_provenance_table_extend(tsk_provenance_table_t *self,\n const tsk_provenance_table_t *other, tsk_size_t num_rows,\n const tsk_id_t *row_indexes, tsk_flags_t options);\n\n/**\n@brief Subset this table by keeping rows according to a boolean mask.\n\n@rst\nDeletes rows from this table and optionally return the mapping from IDs in\nthe current table to the updated table. Rows are kept or deleted according to\nthe specified boolean array ``keep`` such that for each row ``j`` if\n``keep[j]`` is false (zero) the row is deleted, and otherwise the row is\nretained. Thus, ``keep`` must be an array of at least ``num_rows``\n:c:type:`bool` values.\n\nIf the ``id_map`` argument is non-null, this array will be updated to represent\nthe mapping between IDs before and after row deletion. For row ``j``,\n``id_map[j]`` will contain the new ID for row ``j`` if it is retained, or\n:c:macro:`TSK_NULL` if the row has been removed. Thus, ``id_map`` must be an\narray of at least ``num_rows`` :c:type:`tsk_id_t` values.\n\n.. warning::\n C++ users need to be careful to specify the correct type when\n passing in values for the ``keep`` array,\n using ``std::vector`` and not ``std::vector``,\n as the latter may not be correct size.\n\n@endrst\n\n@param self A pointer to a tsk_provenance_table_t object.\n@param keep Array of boolean flags describing whether a particular\n row should be kept or not. Must be at least ``num_rows`` long.\n@param options Bitwise option flags. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@param id_map An array in which to store the mapping between new\n and old IDs. If NULL, this will be ignored.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_provenance_table_keep_rows(tsk_provenance_table_t *self, const tsk_bool_t *keep,\n tsk_flags_t options, tsk_id_t *id_map);\n\n/**\n@brief Returns true if the data in the specified table is identical to the data\n in this table.\n\n@rst\n\n**Options**\n\nOptions to control the comparison can be specified by providing one or\nmore of the following bitwise flags. By default (options=0) tables are\nconsidered equal if they are byte-wise identical in all columns.\n\n- :c:macro:`TSK_CMP_IGNORE_TIMESTAMPS`\n@endrst\n\n@param self A pointer to a tsk_provenance_table_t object.\n@param other A pointer to a tsk_provenance_table_t object.\n@param options Bitwise comparison options.\n@return Return true if the specified table is equal to this table.\n*/\nbool tsk_provenance_table_equals(const tsk_provenance_table_t *self,\n const tsk_provenance_table_t *other, tsk_flags_t options);\n\n/**\n@brief Copies the state of this table into the specified destination.\n\n@rst\nBy default the method initialises the specified destination table. If the\ndestination is already initialised, the :c:macro:`TSK_NO_INIT` option should\nbe supplied to avoid leaking memory.\n@endrst\n\n@param self A pointer to a tsk_provenance_table_t object.\n@param dest A pointer to a tsk_provenance_table_t object. If the TSK_NO_INIT\noption is specified, this must be an initialised provenance table. If not, it must be an\nuninitialised provenance table.\n@param options Bitwise option flags.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_provenance_table_copy(const tsk_provenance_table_t *self,\n tsk_provenance_table_t *dest, tsk_flags_t options);\n\n/**\n@brief Get the row at the specified index.\n\n@rst\nUpdates the specified provenance struct to reflect the values in the specified row.\nPointers to memory within this struct are handled by the table and should **not**\nbe freed by client code. These pointers are guaranteed to be valid until the\nnext operation that modifies the table (e.g., by adding a new row), but not afterwards.\n@endrst\n\n@param self A pointer to a tsk_provenance_table_t object.\n@param index The requested table row.\n@param row A pointer to a tsk_provenance_t struct that is updated to reflect the\n values in the specified row.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_provenance_table_get_row(\n const tsk_provenance_table_t *self, tsk_id_t index, tsk_provenance_t *row);\n\n/**\n@brief Print out the state of this table to the specified stream.\n\nThis method is intended for debugging purposes and should not be used\nin production code. The format of the output should **not** be depended\non and may change arbitrarily between versions.\n\n@param self A pointer to a tsk_provenance_table_t object.\n@param out The stream to write the summary to.\n*/\nvoid tsk_provenance_table_print_state(const tsk_provenance_table_t *self, FILE *out);\n\n/**\n@brief Replace this table's data by copying from a set of column arrays\n\n@rst\nClears the data columns of this table and then copies column data from the specified\nset of arrays. The supplied arrays should all contain data on the same number of rows.\nThe metadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_provenance_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays.\n@param timestamp The array of char timestamp values to be copied.\n@param timestamp_offset The array of tsk_size_t timestamp offset values to be copied.\n@param record The array of char record values to be copied.\n@param record_offset The array of tsk_size_t record offset values to be copied.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_provenance_table_set_columns(tsk_provenance_table_t *self, tsk_size_t num_rows,\n const char *timestamp, const tsk_size_t *timestamp_offset, const char *record,\n const tsk_size_t *record_offset);\n\n/**\n@brief Extends this table by copying from a set of column arrays\n\n@rst\nCopies column data from the specified set of arrays to create new rows at the end of the\ntable. The supplied arrays should all contain data on the same number of rows. The\nmetadata schema is not affected.\n@endrst\n\n@param self A pointer to a tsk_provenance_table_t object.\n@param num_rows The number of rows to copy from the specifed arrays.\n@param timestamp The array of char timestamp values to be copied.\n@param timestamp_offset The array of tsk_size_t timestamp offset values to be copied.\n@param record The array of char record values to be copied.\n@param record_offset The array of tsk_size_t record offset values to be copied.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_provenance_table_append_columns(tsk_provenance_table_t *self,\n tsk_size_t num_rows, const char *timestamp, const tsk_size_t *timestamp_offset,\n const char *record, const tsk_size_t *record_offset);\n\n/**\n@brief Controls the pre-allocation strategy for this table\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_provenance_table_t object.\n@param max_rows_increment The number of rows to pre-allocate, or zero for the default\n doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_provenance_table_set_max_rows_increment(\n tsk_provenance_table_t *self, tsk_size_t max_rows_increment);\n\n/**\n@brief Controls the pre-allocation strategy for the timestamp column\n\n@rst\nSet a fixed pre-allocation size, or use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_provenance_table_t object.\n@param max_timestamp_length_increment The number of bytes to pre-allocate, or zero for\nthe default doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_provenance_table_set_max_timestamp_length_increment(\n tsk_provenance_table_t *self, tsk_size_t max_timestamp_length_increment);\n\n/**\n@brief Controls the pre-allocation strategy for the record column\n\n@rst\nSet a fixed pre-allocation size, use the default doubling strategy.\nSee :ref:`sec_c_api_memory_allocation_strategy` for details on the default\npre-allocation strategy,\n@endrst\n\n@param self A pointer to a tsk_provenance_table_t object.\n@param max_record_length_increment The number of bytes to pre-allocate, or zero for the\ndefault doubling strategy.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_provenance_table_set_max_record_length_increment(\n tsk_provenance_table_t *self, tsk_size_t max_record_length_increment);\n\n/** @} */\n\n/* Undocumented methods */\nint tsk_provenance_table_dump_text(const tsk_provenance_table_t *self, FILE *out);\n\n/****************************************************************************/\n/* Table collection .*/\n/****************************************************************************/\n\n/**\n@defgroup TABLE_COLLECTION_API_GROUP Table collection API.\n@{\n*/\n\n/**\n@brief Initialises the table collection by allocating the internal memory\n and initialising all the constituent tables.\n\n@rst\nThis must be called before any operations are performed on the table\ncollection. See the :ref:`sec_c_api_overview_structure` for details on how objects\nare initialised and freed.\n\n**Options**\n\nOptions can be specified by providing bitwise flags:\n\n- :c:macro:`TSK_TC_NO_EDGE_METADATA`\n@endrst\n\n@param self A pointer to an uninitialised tsk_table_collection_t object.\n@param options Allocation time options as above.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_init(tsk_table_collection_t *self, tsk_flags_t options);\n\n/**\n@brief Free the internal memory for the specified table collection.\n\n@param self A pointer to an initialised tsk_table_collection_t object.\n@return Always returns 0.\n*/\nint tsk_table_collection_free(tsk_table_collection_t *self);\n\n/**\n@brief Clears data tables (and optionally provenances and metadata) in\nthis table collection.\n\n@rst\nBy default this operation clears all tables except the provenance table, retaining\ntable metadata schemas and the tree-sequence level metadata and schema.\n\nNo memory is freed as a result of this operation; please use\n:c:func:`tsk_table_collection_free` to free internal resources.\n\n**Options**\n\nOptions can be specified by providing one or more of the following bitwise\nflags:\n\n- :c:macro:`TSK_CLEAR_PROVENANCE`\n- :c:macro:`TSK_CLEAR_METADATA_SCHEMAS`\n- :c:macro:`TSK_CLEAR_TS_METADATA_AND_SCHEMA`\n@endrst\n\n@param self A pointer to a tsk_table_collection_t object.\n@param options Bitwise clearing options.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_clear(tsk_table_collection_t *self, tsk_flags_t options);\n\n/**\n@brief Returns true if the data in the specified table collection is equal\n to the data in this table collection.\n\n@rst\n\nReturns true if the two table collections are equal. The indexes are\nnot considered as these are derived from the tables. We also do not\nconsider the ``file_uuid``, since it is a property of the file that set\nof tables is stored in.\n\n**Options**\n\nOptions to control the comparison can be specified by providing one or\nmore of the following bitwise flags. By default (options=0) two table\ncollections are considered equal if all of the tables are byte-wise\nidentical, and the sequence lengths, metadata and metadata schemas\nof the two table collections are identical.\n\n- :c:macro:`TSK_CMP_IGNORE_PROVENANCE`\n- :c:macro:`TSK_CMP_IGNORE_METADATA`\n- :c:macro:`TSK_CMP_IGNORE_TS_METADATA`\n- :c:macro:`TSK_CMP_IGNORE_TIMESTAMPS`\n- :c:macro:`TSK_CMP_IGNORE_TABLES`\n- :c:macro:`TSK_CMP_IGNORE_REFERENCE_SEQUENCE`\n@endrst\n\n@param self A pointer to a tsk_table_collection_t object.\n@param other A pointer to a tsk_table_collection_t object.\n@param options Bitwise comparison options.\n@return Return true if the specified table collection is equal to this table.\n*/\nbool tsk_table_collection_equals(const tsk_table_collection_t *self,\n const tsk_table_collection_t *other, tsk_flags_t options);\n\n/**\n@brief Copies the state of this table collection into the specified destination.\n\n@rst\nBy default the method initialises the specified destination table collection. If the\ndestination is already initialised, the :c:macro:`TSK_NO_INIT` option should\nbe supplied to avoid leaking memory.\n\n**Options**\n\nOptions can be specified by providing bitwise flags:\n\n:c:macro:`TSK_COPY_FILE_UUID`\n@endrst\n\n@param self A pointer to a tsk_table_collection_t object.\n@param dest A pointer to a tsk_table_collection_t object. If the TSK_NO_INIT\noption is specified, this must be an initialised table collection. If not, it must be an\nuninitialised table collection.\n@param options Bitwise option flags.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_copy(const tsk_table_collection_t *self,\n tsk_table_collection_t *dest, tsk_flags_t options);\n\n/**\n@brief Print out the state of this table collection to the specified stream.\n\nThis method is intended for debugging purposes and should not be used\nin production code. The format of the output should **not** be depended\non and may change arbitrarily between versions.\n\n@param self A pointer to a tsk_table_collection_t object.\n@param out The stream to write the summary to.\n*/\nvoid tsk_table_collection_print_state(const tsk_table_collection_t *self, FILE *out);\n\n/**\n@brief Load a table collection from a file path.\n\n@rst\nLoads the data from the specified file into this table collection.\nBy default, the table collection is also initialised.\nThe resources allocated must be freed using\n:c:func:`tsk_table_collection_free` even in error conditions.\n\nIf the :c:macro:`TSK_NO_INIT` option is set, the table collection is\nnot initialised, allowing an already initialised table collection to\nbe overwritten with the data from a file.\n\nIf the file contains multiple table collections, this function will load\nthe first. Please see the :c:func:`tsk_table_collection_loadf` for details\non how to sequentially load table collections from a stream.\n\nIf the :c:macro:`TSK_LOAD_SKIP_TABLES` option is set, only the non-table information from\nthe table collection will be read, leaving all tables with zero rows and no\nmetadata or schema.\nIf the :c:macro:`TSK_LOAD_SKIP_REFERENCE_SEQUENCE` option is set, the table collection is\nread without loading the reference sequence.\n\n**Options**\n\nOptions can be specified by providing one or more of the following bitwise\nflags:\n\n- :c:macro:`TSK_NO_INIT`\n- :c:macro:`TSK_LOAD_SKIP_TABLES`\n- :c:macro:`TSK_LOAD_SKIP_REFERENCE_SEQUENCE`\n\n**Examples**\n\n.. code-block:: c\n\n int ret;\n tsk_table_collection_t tables;\n ret = tsk_table_collection_load(&tables, \"data.trees\", 0);\n if (ret != 0) {\n fprintf(stderr, \"Load error:%s\\n\", tsk_strerror(ret));\n exit(EXIT_FAILURE);\n }\n\n@endrst\n\n@param self A pointer to an uninitialised tsk_table_collection_t object\n if the TSK_NO_INIT option is not set (default), or an initialised\n tsk_table_collection_t otherwise.\n@param filename A NULL terminated string containing the filename.\n@param options Bitwise options. See above for details.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_load(\n tsk_table_collection_t *self, const char *filename, tsk_flags_t options);\n\n/**\n@brief Load a table collection from a stream.\n\n@rst\nLoads a tables definition from the specified file stream to this table\ncollection. By default, the table collection is also initialised.\nThe resources allocated must be freed using\n:c:func:`tsk_table_collection_free` even in error conditions.\n\nIf the :c:macro:`TSK_NO_INIT` option is set, the table collection is\nnot initialised, allowing an already initialised table collection to\nbe overwritten with the data from a file.\n\nThe stream can be an arbitrary file descriptor, for example a network socket.\nNo seek operations are performed.\n\nIf the stream contains multiple table collection definitions, this function\nwill load the next table collection from the stream. If the stream contains no\nmore table collection definitions the error value :c:macro:`TSK_ERR_EOF` will\nbe returned. Note that EOF is only returned in the case where zero bytes are\nread from the stream --- malformed files or other errors will result in\ndifferent error conditions. Please see the\n:ref:`sec_c_api_examples_file_streaming` section for an example of how to\nsequentially load tree sequences from a stream.\n\nPlease note that this streaming behaviour is not supported if the\n:c:macro:`TSK_LOAD_SKIP_TABLES` or :c:macro:`TSK_LOAD_SKIP_REFERENCE_SEQUENCE` option is\nset. If the :c:macro:`TSK_LOAD_SKIP_TABLES` option is set, only the non-table information\nfrom the table collection will be read, leaving all tables with zero rows and no metadata\nor schema. If the :c:macro:`TSK_LOAD_SKIP_REFERENCE_SEQUENCE` option is set, the table\ncollection is read without loading the reference sequence. When attempting to read from a\nstream with multiple table collection definitions and either of these two options set,\nthe requested information from the first table collection will be read on the first call\nto :c:func:`tsk_table_collection_loadf`, with subsequent calls leading to errors.\n\n**Options**\n\nOptions can be specified by providing one or more of the following bitwise\nflags:\n\n- :c:macro:`TSK_NO_INIT`\n- :c:macro:`TSK_LOAD_SKIP_TABLES`\n- :c:macro:`TSK_LOAD_SKIP_REFERENCE_SEQUENCE`\n@endrst\n\n@param self A pointer to an uninitialised tsk_table_collection_t object\n if the TSK_NO_INIT option is not set (default), or an initialised\n tsk_table_collection_t otherwise.\n@param file A FILE stream opened in an appropriate mode for reading (e.g.\n \"r\", \"r+\" or \"w+\") positioned at the beginning of a table collection\n definition.\n@param options Bitwise options. See above for details.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_loadf(\n tsk_table_collection_t *self, FILE *file, tsk_flags_t options);\n\n/**\n@brief Write a table collection to file.\n\n@rst\nWrites the data from this table collection to the specified file.\n\nIf an error occurs the file path is deleted, ensuring that only complete\nand well formed files will be written.\n\n**Examples**\n\n.. code-block:: c\n\n int ret;\n tsk_table_collection_t tables;\n\n ret = tsk_table_collection_init(&tables, 0);\n error_check(ret);\n tables.sequence_length = 1.0;\n // Write out the empty tree sequence\n ret = tsk_table_collection_dump(&tables, \"empty.trees\", 0);\n error_check(ret);\n\n@endrst\n\n@param self A pointer to an initialised tsk_table_collection_t object.\n@param filename A NULL terminated string containing the filename.\n@param options Bitwise options. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_dump(\n const tsk_table_collection_t *self, const char *filename, tsk_flags_t options);\n\n/**\n@brief Write a table collection to a stream.\n\n@rst\nWrites the data from this table collection to the specified FILE stream.\nSemantics are identical to :c:func:`tsk_table_collection_dump`.\n\nPlease see the :ref:`sec_c_api_examples_file_streaming` section for an example\nof how to sequentially dump and load tree sequences from a stream.\n\n@endrst\n\n@param self A pointer to an initialised tsk_table_collection_t object.\n@param file A FILE stream opened in an appropriate mode for writing (e.g.\n \"w\", \"a\", \"r+\" or \"w+\").\n@param options Bitwise options. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_dumpf(\n const tsk_table_collection_t *self, FILE *file, tsk_flags_t options);\n\n/**\n@brief Record the number of rows in each table in the specified tsk_bookmark_t object.\n\n@param self A pointer to an initialised tsk_table_collection_t object.\n@param bookmark A pointer to a tsk_bookmark_t which is updated to contain the number of\n rows in all tables.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_record_num_rows(\n const tsk_table_collection_t *self, tsk_bookmark_t *bookmark);\n\n/**\n@brief Truncates the tables in this table collection according to the specified bookmark.\n\n@rst\nTruncate the tables in this collection so that each one has the number\nof rows specified in the parameter :c:type:`tsk_bookmark_t`. Use the\n:c:func:`tsk_table_collection_record_num_rows` function to record the\nnumber rows for each table in a table collection at a particular time.\n@endrst\n\n@param self A pointer to a tsk_individual_table_t object.\n@param bookmark The number of rows to retain in each table.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_truncate(\n tsk_table_collection_t *self, tsk_bookmark_t *bookmark);\n\n/**\n@brief Sorts the tables in this collection.\n\n@rst\nSome of the tables in a table collection must satisfy specific sortedness requirements\nin order to define a :ref:`valid tree sequence `.\nThis method sorts the ``edge``, ``site``, ``mutation`` and ``individual`` tables such\nthat these requirements are guaranteed to be fulfilled. The ``node``, ``population``\nand ``provenance`` tables do not have any sortedness requirements, and are therefore\nignored by this method.\n\n.. note:: The current implementation **may** sort in such a way that exceeds\n these requirements, but this behaviour should not be relied upon and later\n versions may weaken the level of sortedness. However, the method does **guarantee**\n that the resulting tables describes a valid tree sequence.\n\n.. warning:: Sorting migrations is currently not supported and an error will be raised\n if a table collection containing a non-empty migration table is specified.\n\nThe specified :c:type:`tsk_bookmark_t` allows us to specify a start position\nfor sorting in each of the tables; rows before this value are assumed to already be\nin sorted order and this information is used to make sorting more efficient.\nPositions in tables that are not sorted (``node``, ``population``\nand ``provenance``) are ignored and can be set to arbitrary values.\n\n.. warning:: The current implementation only supports specifying a start\n position for the ``edge`` table and in a limited form for the\n ``site``, ``mutation`` and ``individual`` tables. Specifying a non-zero\n ``migration``, start position results in an error. The start positions for the\n ``site``, ``mutation`` and ``individual`` tables can either be 0 or the length of the\n respective tables, allowing these tables to either be fully sorted, or not sorted at\n all.\n\nThe table collection will always be unindexed after sort successfully completes.\n\nFor more control over the sorting process, see the :ref:`sec_c_api_low_level_sorting`\nsection.\n\n**Options**\n\nOptions can be specified by providing one or more of the following bitwise\nflags:\n\n:c:macro:`TSK_NO_CHECK_INTEGRITY`\n Do not run integrity checks using\n :c:func:`tsk_table_collection_check_integrity` before sorting,\n potentially leading to a small reduction in execution time. This\n performance optimisation should not be used unless the calling code can\n guarantee reference integrity within the table collection. References\n to rows not in the table or bad offsets will result in undefined\n behaviour.\n@endrst\n\n@param self A pointer to a tsk_table_collection_t object.\n@param start The position to begin sorting in each table; all rows less than this\n position must fulfill the tree sequence sortedness requirements. If this is\n NULL, sort all rows.\n@param options Sort options.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_sort(\n tsk_table_collection_t *self, const tsk_bookmark_t *start, tsk_flags_t options);\n\n/**\n@brief Sorts the individual table in this collection.\n\n@rst\nSorts the individual table in place, so that parents come before children,\nand the parent column is remapped as required. Node references to individuals\nare also updated.\n@endrst\n\n@param self A pointer to a tsk_table_collection_t object.\n@param options Sort options. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_individual_topological_sort(\n tsk_table_collection_t *self, tsk_flags_t options);\n\n/**\n@brief Puts the tables into canonical form.\n\n@rst\nPut tables into canonical form such that randomly reshuffled tables\nare guaranteed to always be sorted in the same order, and redundant\ninformation is removed. The canonical sorting exceeds the usual\ntree sequence sortedness requirements.\n\n**Options**:\n\nOptions can be specified by providing one or more of the following bitwise\nflags:\n\n- :c:macro:`TSK_SUBSET_KEEP_UNREFERENCED`\n\n@endrst\n\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_canonicalise(tsk_table_collection_t *self, tsk_flags_t options);\n\n/**\n@brief Simplify the tables to remove redundant information.\n\n@rst\nSimplification transforms the tables to remove redundancy and canonicalise\ntree sequence data. See the :ref:`simplification ` tutorial for\nmore details.\n\nA mapping from the node IDs in the table before simplification to their equivalent\nvalues after simplification can be obtained via the ``node_map`` argument. If this\nis non NULL, ``node_map[u]`` will contain the new ID for node ``u`` after simplification,\nor :c:macro:`TSK_NULL` if the node has been removed. Thus, ``node_map`` must be an array\nof at least ``self->nodes.num_rows`` :c:type:`tsk_id_t` values.\n\nIf the `TSK_SIMPLIFY_NO_FILTER_NODES` option is specified, the node table will be\nunaltered except for changing the sample status of nodes (but see the\n`TSK_SIMPLIFY_NO_UPDATE_SAMPLE_FLAGS` option below) and to update references\nto other tables that may have changed as a result of filtering (see below).\nThe ``node_map`` (if specified) will always be the identity mapping, such that\n``node_map[u] == u`` for all nodes. Note also that the order of the list of\nsamples is not important in this case.\n\nWhen a table is not filtered (i.e., if the `TSK_SIMPLIFY_NO_FILTER_NODES`\noption is provided or the `TSK_SIMPLIFY_FILTER_SITES`,\n`TSK_SIMPLIFY_FILTER_POPULATIONS` or `TSK_SIMPLIFY_FILTER_INDIVIDUALS`\noptions are *not* provided) the corresponding table is modified as\nlittle as possible, and all pointers are guaranteed to remain valid\nafter simplification. The only changes made to an unfiltered table are\nto update any references to tables that may have changed (for example,\nremapping population IDs in the node table if\n`TSK_SIMPLIFY_FILTER_POPULATIONS` was specified) or altering the\nsample status flag of nodes.\n\n.. note:: It is possible for populations and individuals to be filtered\n even if `TSK_SIMPLIFY_NO_FILTER_NODES` is specified because there\n may be entirely unreferenced entities in the input tables, which\n are not affected by whether we filter nodes or not.\n\nBy default, the node sample flags are updated by unsetting the\n:c:macro:`TSK_NODE_IS_SAMPLE` flag for all nodes and subsequently setting it\nfor the nodes provided as input to this function. The\n`TSK_SIMPLIFY_NO_UPDATE_SAMPLE_FLAGS` option will prevent this from occuring,\nmaking it the responsibility of calling code to keep track of the ultimate\nsample status of nodes. Using this option in conjunction with\n`TSK_SIMPLIFY_NO_FILTER_NODES` (and without the\n`TSK_SIMPLIFY_FILTER_POPULATIONS` and `TSK_SIMPLIFY_FILTER_INDIVIDUALS`\noptions) guarantees that the node table will not be written to during the\nlifetime of this function.\n\nThe table collection will always be unindexed after simplify successfully completes.\n\n.. note:: Migrations are currently not supported by simplify, and an error will\n be raised if we attempt call simplify on a table collection with greater\n than zero migrations. See ``_\n\n**Options**:\n\nOptions can be specified by providing one or more of the following bitwise\nflags:\n\n- :c:macro:`TSK_SIMPLIFY_FILTER_SITES`\n- :c:macro:`TSK_SIMPLIFY_FILTER_POPULATIONS`\n- :c:macro:`TSK_SIMPLIFY_FILTER_INDIVIDUALS`\n- :c:macro:`TSK_SIMPLIFY_NO_FILTER_NODES`\n- :c:macro:`TSK_SIMPLIFY_NO_UPDATE_SAMPLE_FLAGS`\n- :c:macro:`TSK_SIMPLIFY_REDUCE_TO_SITE_TOPOLOGY`\n- :c:macro:`TSK_SIMPLIFY_KEEP_UNARY`\n- :c:macro:`TSK_SIMPLIFY_KEEP_INPUT_ROOTS`\n- :c:macro:`TSK_SIMPLIFY_KEEP_UNARY_IN_INDIVIDUALS`\n@endrst\n\n@param self A pointer to a tsk_table_collection_t object.\n@param samples Either NULL or an array of num_samples distinct and valid node IDs.\n If non-null the nodes in this array will be marked as samples in the output.\n If NULL, the num_samples parameter is ignored and the samples in the output\n will be the same as the samples in the input. This is equivalent to populating\n the samples array with all of the sample nodes in the input in increasing\n order of ID.\n@param num_samples The number of node IDs in the input samples array. Ignored\n if the samples array is NULL.\n@param options Simplify options; see above for the available bitwise flags.\n For the default behaviour, a value of 0 should be provided.\n@param node_map If not NULL, this array will be filled to define the mapping\n between nodes IDs in the table collection before and after simplification.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_simplify(tsk_table_collection_t *self, const tsk_id_t *samples,\n tsk_size_t num_samples, tsk_flags_t options, tsk_id_t *node_map);\n\n/**\n@brief Subsets and reorders a table collection according to an array of nodes.\n\n@rst\nReduces the table collection to contain only the entries referring to\nthe provided list of nodes, with nodes reordered according to the order\nthey appear in the ``nodes`` argument. Specifically, this subsets and reorders\neach of the tables as follows (but see options, below):\n\n1. Nodes: if in the list of nodes, and in the order provided.\n2. Individuals: if referred to by a retained node.\n3. Populations: if referred to by a retained node, and in the order first seen\n when traversing the list of retained nodes.\n4. Edges: if both parent and child are retained nodes.\n5. Mutations: if the mutation's node is a retained node.\n6. Sites: if any mutations remain at the site after removing mutations.\n\nRetained individuals, edges, mutations, and sites appear in the same\norder as in the original tables. Note that only the information *directly*\nassociated with the provided nodes is retained - for instance,\nsubsetting to nodes=[A, B] does not retain nodes ancestral to A and B,\nand only retains the individuals A and B are in, and not their parents.\n\nThis function does *not* require the tables to be sorted.\n\n.. note:: Migrations are currently not supported by subset, and an error will\n be raised if we attempt call subset on a table collection with greater\n than zero migrations.\n\n**Options**:\n\nOptions can be specified by providing one or more of the following bitwise\nflags:\n\n- :c:macro:`TSK_SUBSET_NO_CHANGE_POPULATIONS`\n- :c:macro:`TSK_SUBSET_KEEP_UNREFERENCED`\n@endrst\n\n@param self A pointer to a tsk_table_collection_t object.\n@param nodes An array of num_nodes valid node IDs.\n@param num_nodes The number of node IDs in the input nodes array.\n@param options Bitwise option flags.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_subset(tsk_table_collection_t *self, const tsk_id_t *nodes,\n tsk_size_t num_nodes, tsk_flags_t options);\n\n/**\n@brief Forms the node-wise union of two table collections.\n\n@rst\nExpands this table collection by adding the non-shared portions of another table\ncollection to itself. The ``other_node_mapping`` encodes which nodes in ``other`` are\nequivalent to a node in ``self``. The positions in the ``other_node_mapping`` array\ncorrespond to node ids in ``other``, and the elements encode the equivalent\nnode id in ``self`` or :c:macro:`TSK_NULL` if the node is exclusive to ``other``. Nodes\nthat are exclusive ``other`` are added to ``self``, along with:\n\n1. Individuals which are new to ``self``.\n2. Edges whose parent or child are new to ``self``.\n3. Sites which were not present in ``self``.\n4. Mutations whose nodes are new to ``self``.\n\nBy default, populations of newly added nodes are assumed to be new populations,\nand added to the population table as well.\n\nThe behavior can be changed by the flags ``TSK_UNION_ALL_EDGES`` and\n``TSK_UNION_ALL_MUTATIONS``, which will (respectively) add *all* edges\nor *all* sites and mutations instead.\n\nThis operation will also sort the resulting tables, so the tables may change\neven if nothing new is added, if the original tables were not sorted.\n\n.. note:: Migrations are currently not supported by union, and an error will\n be raised if we attempt call union on a table collection with migrations.\n\n**Options**:\n\nOptions can be specified by providing one or more of the following bitwise\nflags:\n\n- :c:macro:`TSK_UNION_NO_CHECK_SHARED`\n- :c:macro:`TSK_UNION_NO_ADD_POP`\n@endrst\n\n@param self A pointer to a tsk_table_collection_t object.\n@param other A pointer to a tsk_table_collection_t object.\n@param other_node_mapping An array of node IDs that relate nodes in other to nodes in\nself: the k-th element of other_node_mapping should be the index of the equivalent\nnode in self, or TSK_NULL if the node is not present in self (in which case it\nwill be added to self).\n@param options Union options; see above for the available bitwise flags.\n For the default behaviour, a value of 0 should be provided.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_union(tsk_table_collection_t *self,\n const tsk_table_collection_t *other, const tsk_id_t *other_node_mapping,\n tsk_flags_t options);\n\n/**\n@brief Set the time_units\n@rst\nCopies the time_units string to this table collection, replacing any existing.\n@endrst\n@param self A pointer to a tsk_table_collection_t object.\n@param time_units A pointer to a char array.\n@param time_units_length The size of the time units string in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_set_time_units(\n tsk_table_collection_t *self, const char *time_units, tsk_size_t time_units_length);\n\n/**\n@brief Set the metadata\n@rst\nCopies the metadata string to this table collection, replacing any existing.\n@endrst\n@param self A pointer to a tsk_table_collection_t object.\n@param metadata A pointer to a char array.\n@param metadata_length The size of the metadata in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_set_metadata(\n tsk_table_collection_t *self, const char *metadata, tsk_size_t metadata_length);\n\n/**\n@brief Set the metadata schema\n@rst\nCopies the metadata schema string to this table collection, replacing any existing.\n@endrst\n@param self A pointer to a tsk_table_collection_t object.\n@param metadata_schema A pointer to a char array.\n@param metadata_schema_length The size of the metadata schema in bytes.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_set_metadata_schema(tsk_table_collection_t *self,\n const char *metadata_schema, tsk_size_t metadata_schema_length);\n\n/**\n@brief Returns true if this table collection is indexed.\n\n@rst\nThis method returns true if the table collection has an index\nfor the edge table. It guarantees that the index exists, and that\nit is for the same number of edges that are in the edge table. It\ndoes *not* guarantee that the index is valid (i.e., if the rows\nin the edge have been permuted in some way since the index was built).\n\nSee the :ref:`sec_c_api_table_indexes` section for details on the index\nlife-cycle.\n@endrst\n\n@param self A pointer to a tsk_table_collection_t object.\n@param options Bitwise options. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return true if there is an index present for this table collection.\n*/\nbool tsk_table_collection_has_index(\n const tsk_table_collection_t *self, tsk_flags_t options);\n\n/**\n@brief Deletes the indexes for this table collection.\n\n@rst\nUnconditionally drop the indexes that may be present for this table collection. It\nis not an error to call this method on an unindexed table collection.\nSee the :ref:`sec_c_api_table_indexes` section for details on the index\nlife-cycle.\n@endrst\n\n@param self A pointer to a tsk_table_collection_t object.\n@param options Bitwise options. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Always returns 0.\n*/\nint tsk_table_collection_drop_index(tsk_table_collection_t *self, tsk_flags_t options);\n\n/**\n@brief Builds indexes for this table collection.\n\n@rst\nBuilds the tree traversal :ref:`indexes ` for this table\ncollection. Any existing index is first dropped using\n:c:func:`tsk_table_collection_drop_index`. See the\n:ref:`sec_c_api_table_indexes` section for details on the index life-cycle.\n@endrst\n\n@param self A pointer to a tsk_table_collection_t object.\n@param options Bitwise options. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_collection_build_index(tsk_table_collection_t *self, tsk_flags_t options);\n\n/**\n@brief Runs integrity checks on this table collection.\n\n@rst\n\nChecks the integrity of this table collection. The default checks (i.e., with\noptions = 0) guarantee the integrity of memory and entity references within the\ntable collection. All positions along the genome are checked\nto see if they are finite values and within the required bounds. Time values\nare checked to see if they are finite or marked as unknown.\nConsistency of the direction of inheritance is also checked: whether\nparents are more recent than children, mutations are not more recent\nthan their nodes or their mutation parents, etcetera.\n\nTo check if a set of tables fulfills the :ref:`requirements\n` needed for a valid tree sequence, use\nthe :c:macro:`TSK_CHECK_TREES` option. When this method is called with\n:c:macro:`TSK_CHECK_TREES`, the number of trees in the tree sequence is returned. Thus,\nto check for errors client code should verify that the return value is less than zero.\nAll other options will return zero on success and a negative value on failure.\n\nMore fine-grained checks can be achieved using bitwise combinations of the\nother options.\n\n**Options**:\n\nOptions can be specified by providing one or more of the following bitwise\nflags:\n\n- :c:macro:`TSK_CHECK_EDGE_ORDERING`\n- :c:macro:`TSK_CHECK_SITE_ORDERING`\n- :c:macro:`TSK_CHECK_SITE_DUPLICATES`\n- :c:macro:`TSK_CHECK_MUTATION_ORDERING`\n- :c:macro:`TSK_CHECK_INDIVIDUAL_ORDERING`\n- :c:macro:`TSK_CHECK_MIGRATION_ORDERING`\n- :c:macro:`TSK_CHECK_INDEXES`\n- :c:macro:`TSK_CHECK_TREES`\n- :c:macro:`TSK_NO_CHECK_POPULATION_REFS`\n@endrst\n\n@param self A pointer to a tsk_table_collection_t object.\n@param options Bitwise options.\n@return Return a negative error value on if any problems are detected\n in the tree sequence. If the TSK_CHECK_TREES option is provided,\n the number of trees in the tree sequence will be returned, on\n success.\n*/\ntsk_id_t tsk_table_collection_check_integrity(\n const tsk_table_collection_t *self, tsk_flags_t options);\n\n/** @} */\n\n/* Undocumented methods */\n\n/* Flags for ibd_segments */\n#define TSK_IBD_STORE_PAIRS (1 << 0)\n#define TSK_IBD_STORE_SEGMENTS (1 << 1)\n\n/* TODO be systematic about where \"result\" should be in the params\n * list, different here and in link_ancestors. */\n/* FIXME the order of num_samples and samples needs to be reversed in within.\n * This should be done as part of documenting, I guess. */\nint tsk_table_collection_ibd_within(const tsk_table_collection_t *self,\n tsk_identity_segments_t *result, const tsk_id_t *samples, tsk_size_t num_samples,\n double min_span, double max_time, tsk_flags_t options);\n\nint tsk_table_collection_ibd_between(const tsk_table_collection_t *self,\n tsk_identity_segments_t *result, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, double min_span,\n double max_time, tsk_flags_t options);\n\nint tsk_table_collection_link_ancestors(tsk_table_collection_t *self, tsk_id_t *samples,\n tsk_size_t num_samples, tsk_id_t *ancestors, tsk_size_t num_ancestors,\n tsk_flags_t options, tsk_edge_table_t *result);\nint tsk_table_collection_deduplicate_sites(\n tsk_table_collection_t *tables, tsk_flags_t options);\nint tsk_table_collection_compute_mutation_parents(\n tsk_table_collection_t *self, tsk_flags_t options);\nint tsk_table_collection_compute_mutation_times(\n tsk_table_collection_t *self, double *random, tsk_flags_t options);\nint tsk_table_collection_delete_older(\n tsk_table_collection_t *self, double time, tsk_flags_t options);\n\nint tsk_table_collection_set_indexes(tsk_table_collection_t *self,\n tsk_id_t *edge_insertion_order, tsk_id_t *edge_removal_order);\n\nint tsk_table_collection_takeset_metadata(\n tsk_table_collection_t *self, char *metadata, tsk_size_t metadata_length);\nint tsk_table_collection_takeset_indexes(tsk_table_collection_t *self,\n tsk_id_t *edge_insertion_order, tsk_id_t *edge_removal_order);\nint tsk_individual_table_takeset_columns(tsk_individual_table_t *self,\n tsk_size_t num_rows, tsk_flags_t *flags, double *location,\n tsk_size_t *location_offset, tsk_id_t *parents, tsk_size_t *parents_offset,\n char *metadata, tsk_size_t *metadata_offset);\nint tsk_node_table_takeset_columns(tsk_node_table_t *self, tsk_size_t num_rows,\n tsk_flags_t *flags, double *time, tsk_id_t *population, tsk_id_t *individual,\n char *metadata, tsk_size_t *metadata_offset);\nint tsk_edge_table_takeset_columns(tsk_edge_table_t *self, tsk_size_t num_rows,\n double *left, double *right, tsk_id_t *parent, tsk_id_t *child, char *metadata,\n tsk_size_t *metadata_offset);\nint tsk_migration_table_takeset_columns(tsk_migration_table_t *self, tsk_size_t num_rows,\n double *left, double *right, tsk_id_t *node, tsk_id_t *source, tsk_id_t *dest,\n double *time, char *metadata, tsk_size_t *metadata_offset);\nint tsk_site_table_takeset_columns(tsk_site_table_t *self, tsk_size_t num_rows,\n double *position, char *ancestral_state, tsk_size_t *ancestral_state_offset,\n char *metadata, tsk_size_t *metadata_offset);\nint tsk_mutation_table_takeset_columns(tsk_mutation_table_t *self, tsk_size_t num_rows,\n tsk_id_t *site, tsk_id_t *node, tsk_id_t *parent, double *time, char *derived_state,\n tsk_size_t *derived_state_offset, char *metadata, tsk_size_t *metadata_offset);\nint tsk_population_table_takeset_columns(tsk_population_table_t *self,\n tsk_size_t num_rows, char *metadata, tsk_size_t *metadata_offset);\nint tsk_provenance_table_takeset_columns(tsk_provenance_table_t *self,\n tsk_size_t num_rows, char *timestamp, tsk_size_t *timestamp_offset, char *record,\n tsk_size_t *record_offset);\n\nbool tsk_table_collection_has_reference_sequence(const tsk_table_collection_t *self);\n\nint tsk_reference_sequence_init(tsk_reference_sequence_t *self, tsk_flags_t options);\nint tsk_reference_sequence_free(tsk_reference_sequence_t *self);\nbool tsk_reference_sequence_is_null(const tsk_reference_sequence_t *self);\nbool tsk_reference_sequence_equals(const tsk_reference_sequence_t *self,\n const tsk_reference_sequence_t *other, tsk_flags_t options);\nint tsk_reference_sequence_copy(const tsk_reference_sequence_t *self,\n tsk_reference_sequence_t *dest, tsk_flags_t options);\nint tsk_reference_sequence_set_data(\n tsk_reference_sequence_t *self, const char *data, tsk_size_t data_length);\nint tsk_reference_sequence_set_url(\n tsk_reference_sequence_t *self, const char *url, tsk_size_t url_length);\nint tsk_reference_sequence_set_metadata(\n tsk_reference_sequence_t *self, const char *metadata, tsk_size_t metadata_length);\nint tsk_reference_sequence_set_metadata_schema(tsk_reference_sequence_t *self,\n const char *metadata_schema, tsk_size_t metadata_schema_length);\nint tsk_reference_sequence_takeset_data(\n tsk_reference_sequence_t *self, char *data, tsk_size_t data_length);\nint tsk_reference_sequence_takeset_metadata(\n tsk_reference_sequence_t *self, char *metadata, tsk_size_t metadata_length);\n\n/**\n@defgroup TABLE_SORTER_API_GROUP Low-level table sorter API.\n@{\n*/\n\n/* NOTE: We use the \"struct _tsk_table_sorter_t\" form here\n * rather then the usual tsk_table_sorter_t alias because\n * of problems with Doxygen. This was the only way I could\n * get it to work - ideally, we'd use the usual typedefs\n * to avoid confusing people.\n */\n\n/**\n@brief Initialises the memory for the sorter object.\n\n@rst\nThis must be called before any operations are performed on the\ntable sorter and initialises all fields. The ``edge_sort`` function\nis set to the default method using qsort. The ``user_data``\nfield is set to NULL.\nThis method supports the same options as\n:c:func:`tsk_table_collection_sort`.\n\n@endrst\n\n@param self A pointer to an uninitialised tsk_table_sorter_t object.\n@param tables The table collection to sort.\n@param options Sorting options.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_sorter_init(struct _tsk_table_sorter_t *self,\n tsk_table_collection_t *tables, tsk_flags_t options);\n\n/**\n@brief Runs the sort using the configured functions.\n\n@rst\nRuns the sorting process:\n\n1. Drop the table indexes.\n2. If the ``sort_edges`` function pointer is not NULL, run it. The\n first parameter to the called function will be a pointer to this\n table_sorter_t object. The second parameter will be the value\n ``start.edges``. This specifies the offset at which sorting should\n start in the edge table. This offset is guaranteed to be within the\n bounds of the edge table.\n3. Sort the site table, building the mapping between site IDs in the\n current and sorted tables.\n4. Sort the mutation table, using the ``sort_mutations`` pointer.\n\nIf an error occurs during the execution of a user-supplied\nsorting function a non-zero value must be returned. This value\nwill then be returned by ``tsk_table_sorter_run``. The error\nreturn value should be chosen to avoid conflicts with tskit error\ncodes.\n\nSee :c:func:`tsk_table_collection_sort` for details on the ``start`` parameter.\n\n@endrst\n\n@param self A pointer to a tsk_table_sorter_t object.\n@param start The position in the tables at which sorting starts.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_table_sorter_run(struct _tsk_table_sorter_t *self, const tsk_bookmark_t *start);\n\n/**\n@brief Free the internal memory for the specified table sorter.\n\n@param self A pointer to an initialised tsk_table_sorter_t object.\n@return Always returns 0.\n*/\nint tsk_table_sorter_free(struct _tsk_table_sorter_t *self);\n\n/** @} */\n\nint tsk_squash_edges(\n tsk_edge_t *edges, tsk_size_t num_edges, tsk_size_t *num_output_edges);\n\n/* IBD segments API. This is experimental and the interface may change. */\n\ntsk_size_t tsk_identity_segments_get_num_segments(const tsk_identity_segments_t *self);\ndouble tsk_identity_segments_get_total_span(const tsk_identity_segments_t *self);\ntsk_size_t tsk_identity_segments_get_num_pairs(const tsk_identity_segments_t *self);\nint tsk_identity_segments_get_keys(\n const tsk_identity_segments_t *result, tsk_id_t *pairs);\nint tsk_identity_segments_get_items(const tsk_identity_segments_t *self, tsk_id_t *pairs,\n tsk_identity_segment_list_t **lists);\nint tsk_identity_segments_get(const tsk_identity_segments_t *self, tsk_id_t a,\n tsk_id_t b, tsk_identity_segment_list_t **ret_list);\nvoid tsk_identity_segments_print_state(tsk_identity_segments_t *self, FILE *out);\nint tsk_identity_segments_free(tsk_identity_segments_t *self);\n\n#ifdef __cplusplus\n}\n#endif\n#endif\n"
},
{
"path": "c/tskit/trees.c",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2025 Tskit Developers\n * Copyright (c) 2015-2018 University of Oxford\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\nstatic inline bool\nis_discrete(double x)\n{\n return trunc(x) == x;\n}\n\n/* ======================================================== *\n * tree sequence\n * ======================================================== */\n\nstatic void\ntsk_treeseq_check_state(const tsk_treeseq_t *self)\n{\n tsk_size_t j;\n tsk_size_t k, l;\n tsk_site_t site;\n tsk_id_t site_id = 0;\n\n for (j = 0; j < self->num_trees; j++) {\n for (k = 0; k < self->tree_sites_length[j]; k++) {\n site = self->tree_sites[j][k];\n tsk_bug_assert(site.id == site_id);\n site_id++;\n for (l = 0; l < site.mutations_length; l++) {\n tsk_bug_assert(site.mutations[l].site == site.id);\n }\n }\n }\n}\n\nvoid\ntsk_treeseq_print_state(const tsk_treeseq_t *self, FILE *out)\n{\n tsk_size_t j;\n tsk_size_t k, l, m;\n tsk_site_t site;\n\n fprintf(out, \"tree_sequence state\\n\");\n fprintf(out, \"num_trees = %lld\\n\", (long long) self->num_trees);\n fprintf(out, \"samples = (%lld)\\n\", (long long) self->num_samples);\n for (j = 0; j < self->num_samples; j++) {\n fprintf(out, \"\\t%lld\\n\", (long long) self->samples[j]);\n }\n tsk_table_collection_print_state(self->tables, out);\n fprintf(out, \"tree_sites = \\n\");\n for (j = 0; j < self->num_trees; j++) {\n fprintf(out, \"tree %lld\\t%lld sites\\n\", (long long) j,\n (long long) self->tree_sites_length[j]);\n for (k = 0; k < self->tree_sites_length[j]; k++) {\n site = self->tree_sites[j][k];\n fprintf(out, \"\\tsite %lld pos = %f ancestral state = \", (long long) site.id,\n site.position);\n for (l = 0; l < site.ancestral_state_length; l++) {\n fprintf(out, \"%c\", site.ancestral_state[l]);\n }\n fprintf(out, \" %lld mutations\\n\", (long long) site.mutations_length);\n for (l = 0; l < site.mutations_length; l++) {\n fprintf(out, \"\\t\\tmutation %lld node = %lld derived_state = \",\n (long long) site.mutations[l].id,\n (long long) site.mutations[l].node);\n for (m = 0; m < site.mutations[l].derived_state_length; m++) {\n fprintf(out, \"%c\", site.mutations[l].derived_state[m]);\n }\n fprintf(out, \"\\n\");\n }\n }\n }\n tsk_treeseq_check_state(self);\n}\n\nint\ntsk_treeseq_free(tsk_treeseq_t *self)\n{\n if (self->tables != NULL) {\n tsk_table_collection_free(self->tables);\n }\n tsk_safe_free(self->tables);\n tsk_safe_free(self->samples);\n tsk_safe_free(self->sample_index_map);\n tsk_safe_free(self->breakpoints);\n tsk_safe_free(self->tree_sites);\n tsk_safe_free(self->tree_sites_length);\n tsk_safe_free(self->tree_sites_mem);\n tsk_safe_free(self->site_mutations_mem);\n tsk_safe_free(self->site_mutations_length);\n tsk_safe_free(self->site_mutations);\n tsk_safe_free(self->individual_nodes_mem);\n tsk_safe_free(self->individual_nodes_length);\n tsk_safe_free(self->individual_nodes);\n return 0;\n}\n\nstatic int\ntsk_treeseq_init_sites(tsk_treeseq_t *self)\n{\n tsk_id_t j, k;\n int ret = 0;\n tsk_size_t offset = 0;\n const tsk_size_t num_mutations = self->tables->mutations.num_rows;\n const tsk_size_t num_sites = self->tables->sites.num_rows;\n const tsk_id_t *restrict mutation_site = self->tables->mutations.site;\n const double *restrict site_position = self->tables->sites.position;\n bool discrete_sites = true;\n tsk_mutation_t *mutation;\n\n self->site_mutations_mem\n = tsk_malloc(num_mutations * sizeof(*self->site_mutations_mem));\n self->site_mutations_length\n = tsk_malloc(num_sites * sizeof(*self->site_mutations_length));\n self->site_mutations = tsk_malloc(num_sites * sizeof(*self->site_mutations));\n self->tree_sites_mem = tsk_malloc(num_sites * sizeof(*self->tree_sites_mem));\n if (self->site_mutations_mem == NULL || self->site_mutations_length == NULL\n || self->site_mutations == NULL || self->tree_sites_mem == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n for (k = 0; k < (tsk_id_t) num_mutations; k++) {\n mutation = self->site_mutations_mem + k;\n ret = tsk_treeseq_get_mutation(self, k, mutation);\n if (ret != 0) {\n goto out;\n }\n }\n k = 0;\n for (j = 0; j < (tsk_id_t) num_sites; j++) {\n discrete_sites = discrete_sites && is_discrete(site_position[j]);\n self->site_mutations[j] = self->site_mutations_mem + offset;\n self->site_mutations_length[j] = 0;\n /* Go through all mutations for this site */\n while (k < (tsk_id_t) num_mutations && mutation_site[k] == j) {\n self->site_mutations_length[j]++;\n offset++;\n k++;\n }\n ret = tsk_treeseq_get_site(self, j, self->tree_sites_mem + j);\n if (ret != 0) {\n goto out;\n }\n }\n self->discrete_genome = self->discrete_genome && discrete_sites;\nout:\n return ret;\n}\n\nstatic int\ntsk_treeseq_init_individuals(tsk_treeseq_t *self)\n{\n int ret = 0;\n tsk_id_t node;\n tsk_id_t ind;\n tsk_size_t offset = 0;\n tsk_size_t total_node_refs = 0;\n tsk_size_t *node_count = NULL;\n tsk_id_t *node_array;\n const tsk_size_t num_inds = self->tables->individuals.num_rows;\n const tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const tsk_id_t *restrict node_individual = self->tables->nodes.individual;\n\n // First find number of nodes per individual\n self->individual_nodes_length\n = tsk_calloc(TSK_MAX(1, num_inds), sizeof(*self->individual_nodes_length));\n node_count = tsk_calloc(TSK_MAX(1, num_inds), sizeof(*node_count));\n\n if (self->individual_nodes_length == NULL || node_count == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n for (node = 0; node < (tsk_id_t) num_nodes; node++) {\n ind = node_individual[node];\n if (ind != TSK_NULL) {\n self->individual_nodes_length[ind]++;\n total_node_refs++;\n }\n }\n\n self->individual_nodes_mem\n = tsk_malloc(TSK_MAX(1, total_node_refs) * sizeof(tsk_node_t));\n self->individual_nodes = tsk_malloc(TSK_MAX(1, num_inds) * sizeof(tsk_node_t *));\n if (self->individual_nodes_mem == NULL || self->individual_nodes == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n /* Now fill in the node IDs */\n for (ind = 0; ind < (tsk_id_t) num_inds; ind++) {\n self->individual_nodes[ind] = self->individual_nodes_mem + offset;\n offset += self->individual_nodes_length[ind];\n }\n for (node = 0; node < (tsk_id_t) num_nodes; node++) {\n ind = node_individual[node];\n if (ind != TSK_NULL) {\n node_array = self->individual_nodes[ind];\n tsk_bug_assert(node_array - self->individual_nodes_mem\n < (tsk_id_t) (total_node_refs - node_count[ind]));\n node_array[node_count[ind]] = node;\n node_count[ind] += 1;\n }\n }\nout:\n tsk_safe_free(node_count);\n return ret;\n}\n\n/* Initialises memory associated with the trees.\n */\nstatic int\ntsk_treeseq_init_trees(tsk_treeseq_t *self)\n{\n int ret = TSK_ERR_GENERIC;\n tsk_size_t j, k, tree_index;\n tsk_id_t site_id, edge_id, mutation_id;\n double tree_left, tree_right;\n const double sequence_length = self->tables->sequence_length;\n const tsk_id_t num_sites = (tsk_id_t) self->tables->sites.num_rows;\n const tsk_id_t num_mutations = (tsk_id_t) self->tables->mutations.num_rows;\n const tsk_size_t num_edges = self->tables->edges.num_rows;\n const tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const double *restrict site_position = self->tables->sites.position;\n const tsk_id_t *restrict mutation_site = self->tables->mutations.site;\n const tsk_id_t *restrict mutation_parent = self->tables->mutations.parent;\n const char *restrict sites_ancestral_state = self->tables->sites.ancestral_state;\n const tsk_size_t *restrict sites_ancestral_state_offset\n = self->tables->sites.ancestral_state_offset;\n const char *restrict mutations_derived_state = self->tables->mutations.derived_state;\n const tsk_size_t *restrict mutations_derived_state_offset\n = self->tables->mutations.derived_state_offset;\n const tsk_id_t *restrict I = self->tables->indexes.edge_insertion_order;\n const tsk_id_t *restrict O = self->tables->indexes.edge_removal_order;\n const double *restrict edge_right = self->tables->edges.right;\n const double *restrict edge_left = self->tables->edges.left;\n const tsk_id_t *restrict edge_child = self->tables->edges.child;\n tsk_size_t num_trees_alloc = self->num_trees + 1;\n bool discrete_breakpoints = true;\n tsk_id_t *node_edge_map = tsk_malloc(num_nodes * sizeof(*node_edge_map));\n tsk_mutation_t *mutation;\n tsk_id_t parent_id;\n\n self->tree_sites_length\n = tsk_malloc(num_trees_alloc * sizeof(*self->tree_sites_length));\n self->tree_sites = tsk_malloc(num_trees_alloc * sizeof(*self->tree_sites));\n self->breakpoints = tsk_malloc(num_trees_alloc * sizeof(*self->breakpoints));\n if (node_edge_map == NULL || self->tree_sites == NULL\n || self->tree_sites_length == NULL || self->breakpoints == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(\n self->tree_sites_length, 0, self->num_trees * sizeof(*self->tree_sites_length));\n tsk_memset(self->tree_sites, 0, self->num_trees * sizeof(*self->tree_sites));\n tsk_memset(node_edge_map, TSK_NULL, num_nodes * sizeof(*node_edge_map));\n\n tree_left = 0;\n tree_right = sequence_length;\n tree_index = 0;\n site_id = 0;\n mutation_id = 0;\n j = 0;\n k = 0;\n while (j < num_edges || tree_left < sequence_length) {\n discrete_breakpoints = discrete_breakpoints && is_discrete(tree_left);\n self->breakpoints[tree_index] = tree_left;\n while (k < num_edges && edge_right[O[k]] == tree_left) {\n edge_id = O[k];\n node_edge_map[edge_child[edge_id]] = TSK_NULL;\n k++;\n }\n while (j < num_edges && edge_left[I[j]] == tree_left) {\n edge_id = I[j];\n node_edge_map[edge_child[edge_id]] = edge_id;\n j++;\n }\n tree_right = sequence_length;\n if (j < num_edges) {\n tree_right = TSK_MIN(tree_right, edge_left[I[j]]);\n }\n if (k < num_edges) {\n tree_right = TSK_MIN(tree_right, edge_right[O[k]]);\n }\n self->tree_sites[tree_index] = self->tree_sites_mem + site_id;\n while (site_id < num_sites && site_position[site_id] < tree_right) {\n self->tree_sites_length[tree_index]++;\n while (\n mutation_id < num_mutations && mutation_site[mutation_id] == site_id) {\n mutation = self->site_mutations_mem + mutation_id;\n mutation->edge = node_edge_map[mutation->node];\n\n /* Compute inherited state */\n if (mutation_parent[mutation_id] == TSK_NULL) {\n /* No parent: inherited state is the site's ancestral state */\n mutation->inherited_state\n = sites_ancestral_state + sites_ancestral_state_offset[site_id];\n mutation->inherited_state_length\n = sites_ancestral_state_offset[site_id + 1]\n - sites_ancestral_state_offset[site_id];\n } else {\n /* Has parent: inherited state is parent's derived state */\n parent_id = mutation_parent[mutation_id];\n mutation->inherited_state\n = mutations_derived_state\n + mutations_derived_state_offset[parent_id];\n mutation->inherited_state_length\n = mutations_derived_state_offset[parent_id + 1]\n - mutations_derived_state_offset[parent_id];\n }\n\n mutation_id++;\n }\n site_id++;\n }\n tree_left = tree_right;\n tree_index++;\n }\n tsk_bug_assert(site_id == num_sites);\n tsk_bug_assert(tree_index == self->num_trees);\n self->breakpoints[tree_index] = tree_right;\n discrete_breakpoints = discrete_breakpoints && is_discrete(tree_right);\n self->discrete_genome = self->discrete_genome && discrete_breakpoints;\n ret = 0;\nout:\n tsk_safe_free(node_edge_map);\n return ret;\n}\n\nstatic void\ntsk_treeseq_init_migrations(tsk_treeseq_t *self)\n{\n tsk_size_t j;\n tsk_size_t num_migrations = self->tables->migrations.num_rows;\n const double *restrict left = self->tables->migrations.left;\n const double *restrict right = self->tables->migrations.right;\n const double *restrict time = self->tables->migrations.time;\n bool discrete_breakpoints = true;\n bool discrete_times = true;\n\n for (j = 0; j < num_migrations; j++) {\n discrete_breakpoints\n = discrete_breakpoints && is_discrete(left[j]) && is_discrete(right[j]);\n discrete_times\n = discrete_times && (is_discrete(time[j]) || tsk_is_unknown_time(time[j]));\n }\n self->discrete_genome = self->discrete_genome && discrete_breakpoints;\n self->discrete_time = self->discrete_time && discrete_times;\n}\n\nstatic void\ntsk_treeseq_init_mutations(tsk_treeseq_t *self)\n{\n tsk_size_t j;\n tsk_size_t num_mutations = self->tables->mutations.num_rows;\n const double *restrict time = self->tables->mutations.time;\n bool discrete_times = true;\n\n for (j = 0; j < num_mutations; j++) {\n discrete_times\n = discrete_times && (is_discrete(time[j]) || tsk_is_unknown_time(time[j]));\n }\n self->discrete_time = self->discrete_time && discrete_times;\n\n for (j = 0; j < num_mutations; j++) {\n if (!tsk_is_unknown_time(time[j])) {\n self->min_time = TSK_MIN(self->min_time, time[j]);\n self->max_time = TSK_MAX(self->max_time, time[j]);\n }\n }\n}\n\nstatic int\ntsk_treeseq_init_nodes(tsk_treeseq_t *self)\n{\n tsk_size_t j, k;\n tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const tsk_flags_t *restrict node_flags = self->tables->nodes.flags;\n const double *restrict time = self->tables->nodes.time;\n int ret = 0;\n bool discrete_times = true;\n\n /* Determine the sample size */\n self->num_samples = 0;\n for (j = 0; j < num_nodes; j++) {\n if (!!(node_flags[j] & TSK_NODE_IS_SAMPLE)) {\n self->num_samples++;\n }\n }\n /* TODO raise an error if < 2 samples?? */\n self->samples = tsk_malloc(self->num_samples * sizeof(tsk_id_t));\n self->sample_index_map = tsk_malloc(num_nodes * sizeof(tsk_id_t));\n if (self->samples == NULL || self->sample_index_map == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n k = 0;\n for (j = 0; j < num_nodes; j++) {\n self->sample_index_map[j] = -1;\n if (!!(node_flags[j] & TSK_NODE_IS_SAMPLE)) {\n self->samples[k] = (tsk_id_t) j;\n self->sample_index_map[j] = (tsk_id_t) k;\n k++;\n }\n }\n tsk_bug_assert(k == self->num_samples);\n\n for (j = 0; j < num_nodes; j++) {\n discrete_times\n = discrete_times && (is_discrete(time[j]) || tsk_is_unknown_time(time[j]));\n }\n self->discrete_time = self->discrete_time && discrete_times;\n\n for (j = 0; j < num_nodes; j++) {\n if (!tsk_is_unknown_time(time[j])) {\n self->min_time = TSK_MIN(self->min_time, time[j]);\n self->max_time = TSK_MAX(self->max_time, time[j]);\n }\n }\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_init(\n tsk_treeseq_t *self, tsk_table_collection_t *tables, tsk_flags_t options)\n{\n int ret = 0;\n tsk_id_t num_trees;\n\n tsk_memset(self, 0, sizeof(*self));\n if (options & TSK_TAKE_OWNERSHIP) {\n self->tables = tables;\n if (tables->edges.options & TSK_TABLE_NO_METADATA) {\n ret = tsk_trace_error(TSK_ERR_CANT_TAKE_OWNERSHIP_NO_EDGE_METADATA);\n goto out;\n }\n } else {\n self->tables = tsk_malloc(sizeof(*self->tables));\n if (self->tables == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n /* Note that this copy reinstates metadata for a table collection with\n * TSK_TC_NO_EDGE_METADATA. Otherwise a table without metadata would\n * crash tsk_diff_iter_next. */\n ret = tsk_table_collection_copy(tables, self->tables, TSK_COPY_FILE_UUID);\n if (ret != 0) {\n goto out;\n }\n }\n if (options & TSK_TS_INIT_BUILD_INDEXES) {\n ret = tsk_table_collection_build_index(self->tables, 0);\n if (ret != 0) {\n goto out;\n }\n }\n\n if (options & TSK_TS_INIT_COMPUTE_MUTATION_PARENTS) {\n /* As tsk_table_collection_compute_mutation_parents performs an\n integrity check, and we don't wish to do that twice we perform\n our own check here */\n num_trees = tsk_table_collection_check_integrity(self->tables, TSK_CHECK_TREES);\n if (num_trees < 0) {\n ret = (int) num_trees;\n goto out;\n }\n\n ret = tsk_table_collection_compute_mutation_parents(\n self->tables, TSK_NO_CHECK_INTEGRITY);\n if (ret != 0) {\n goto out;\n }\n } else {\n num_trees = tsk_table_collection_check_integrity(\n self->tables, TSK_CHECK_TREES | TSK_CHECK_MUTATION_PARENTS);\n if (num_trees < 0) {\n ret = (int) num_trees;\n goto out;\n }\n }\n self->num_trees = (tsk_size_t) num_trees;\n self->discrete_genome = true;\n self->discrete_time = true;\n self->min_time = INFINITY;\n self->max_time = -INFINITY;\n ret = tsk_treeseq_init_nodes(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_init_sites(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_init_individuals(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_init_trees(self);\n if (ret != 0) {\n goto out;\n }\n tsk_treeseq_init_migrations(self);\n tsk_treeseq_init_mutations(self);\n\n if (tsk_treeseq_get_time_units_length(self) == strlen(TSK_TIME_UNITS_UNCALIBRATED)\n && !strncmp(tsk_treeseq_get_time_units(self), TSK_TIME_UNITS_UNCALIBRATED,\n strlen(TSK_TIME_UNITS_UNCALIBRATED))) {\n self->time_uncalibrated = true;\n }\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_copy_tables(\n const tsk_treeseq_t *self, tsk_table_collection_t *tables, tsk_flags_t options)\n{\n return tsk_table_collection_copy(self->tables, tables, options);\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_load(tsk_treeseq_t *self, const char *filename, tsk_flags_t options)\n{\n int ret = 0;\n tsk_table_collection_t *tables = malloc(sizeof(*tables));\n\n /* Need to make sure that we're zero'd out in case of error */\n tsk_memset(self, 0, sizeof(*self));\n\n if (tables == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n ret = tsk_table_collection_load(tables, filename, options);\n if (ret != 0) {\n tsk_table_collection_free(tables);\n tsk_safe_free(tables);\n goto out;\n }\n /* TSK_TAKE_OWNERSHIP takes immediate ownership of the tables, regardless\n * of error conditions. */\n ret = tsk_treeseq_init(self, tables, TSK_TAKE_OWNERSHIP);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_loadf(tsk_treeseq_t *self, FILE *file, tsk_flags_t options)\n{\n int ret = 0;\n tsk_table_collection_t *tables = malloc(sizeof(*tables));\n\n /* Need to make sure that we're zero'd out in case of error */\n tsk_memset(self, 0, sizeof(*self));\n\n if (tables == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n ret = tsk_table_collection_loadf(tables, file, options);\n if (ret != 0) {\n tsk_table_collection_free(tables);\n tsk_safe_free(tables);\n goto out;\n }\n /* TSK_TAKE_OWNERSHIP takes immediate ownership of the tables, regardless\n * of error conditions. */\n ret = tsk_treeseq_init(self, tables, TSK_TAKE_OWNERSHIP);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_dump(const tsk_treeseq_t *self, const char *filename, tsk_flags_t options)\n{\n return tsk_table_collection_dump(self->tables, filename, options);\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_dumpf(const tsk_treeseq_t *self, FILE *file, tsk_flags_t options)\n{\n return tsk_table_collection_dumpf(self->tables, file, options);\n}\n\n/* Simple attribute getters */\n\nconst char *\ntsk_treeseq_get_metadata(const tsk_treeseq_t *self)\n{\n return self->tables->metadata;\n}\n\ntsk_size_t\ntsk_treeseq_get_metadata_length(const tsk_treeseq_t *self)\n{\n return self->tables->metadata_length;\n}\n\nconst char *\ntsk_treeseq_get_metadata_schema(const tsk_treeseq_t *self)\n{\n return self->tables->metadata_schema;\n}\n\ntsk_size_t\ntsk_treeseq_get_metadata_schema_length(const tsk_treeseq_t *self)\n{\n return self->tables->metadata_schema_length;\n}\n\nconst char *\ntsk_treeseq_get_time_units(const tsk_treeseq_t *self)\n{\n return self->tables->time_units;\n}\n\ntsk_size_t\ntsk_treeseq_get_time_units_length(const tsk_treeseq_t *self)\n{\n return self->tables->time_units_length;\n}\n\ndouble\ntsk_treeseq_get_sequence_length(const tsk_treeseq_t *self)\n{\n return self->tables->sequence_length;\n}\n\nconst char *\ntsk_treeseq_get_file_uuid(const tsk_treeseq_t *self)\n{\n return self->tables->file_uuid;\n}\n\ntsk_size_t\ntsk_treeseq_get_num_samples(const tsk_treeseq_t *self)\n{\n return self->num_samples;\n}\n\ntsk_size_t\ntsk_treeseq_get_num_nodes(const tsk_treeseq_t *self)\n{\n return self->tables->nodes.num_rows;\n}\n\ntsk_size_t\ntsk_treeseq_get_num_edges(const tsk_treeseq_t *self)\n{\n return self->tables->edges.num_rows;\n}\n\ntsk_size_t\ntsk_treeseq_get_num_migrations(const tsk_treeseq_t *self)\n{\n return self->tables->migrations.num_rows;\n}\n\ntsk_size_t\ntsk_treeseq_get_num_sites(const tsk_treeseq_t *self)\n{\n return self->tables->sites.num_rows;\n}\n\ntsk_size_t\ntsk_treeseq_get_num_mutations(const tsk_treeseq_t *self)\n{\n return self->tables->mutations.num_rows;\n}\n\ntsk_size_t\ntsk_treeseq_get_num_populations(const tsk_treeseq_t *self)\n{\n return self->tables->populations.num_rows;\n}\n\ntsk_size_t\ntsk_treeseq_get_num_individuals(const tsk_treeseq_t *self)\n{\n return self->tables->individuals.num_rows;\n}\n\ntsk_size_t\ntsk_treeseq_get_num_provenances(const tsk_treeseq_t *self)\n{\n return self->tables->provenances.num_rows;\n}\n\ntsk_size_t\ntsk_treeseq_get_num_trees(const tsk_treeseq_t *self)\n{\n return self->num_trees;\n}\n\nconst double *\ntsk_treeseq_get_breakpoints(const tsk_treeseq_t *self)\n{\n return self->breakpoints;\n}\n\nconst tsk_id_t *\ntsk_treeseq_get_samples(const tsk_treeseq_t *self)\n{\n return self->samples;\n}\n\nconst tsk_id_t *\ntsk_treeseq_get_sample_index_map(const tsk_treeseq_t *self)\n{\n return self->sample_index_map;\n}\n\nbool\ntsk_treeseq_is_sample(const tsk_treeseq_t *self, tsk_id_t u)\n{\n bool ret = false;\n\n if (u >= 0 && u < (tsk_id_t) self->tables->nodes.num_rows) {\n ret = !!(self->tables->nodes.flags[u] & TSK_NODE_IS_SAMPLE);\n }\n return ret;\n}\n\nbool\ntsk_treeseq_get_discrete_genome(const tsk_treeseq_t *self)\n{\n return self->discrete_genome;\n}\n\nbool\ntsk_treeseq_get_discrete_time(const tsk_treeseq_t *self)\n{\n return self->discrete_time;\n}\n\ndouble\ntsk_treeseq_get_min_time(const tsk_treeseq_t *self)\n{\n return self->min_time;\n}\n\ndouble\ntsk_treeseq_get_max_time(const tsk_treeseq_t *self)\n{\n return self->max_time;\n}\n\nbool\ntsk_treeseq_has_reference_sequence(const tsk_treeseq_t *self)\n{\n return tsk_table_collection_has_reference_sequence(self->tables);\n}\n\nint\ntsk_treeseq_get_individuals_population(const tsk_treeseq_t *self, tsk_id_t *output)\n{\n int ret = 0;\n tsk_size_t i, j;\n tsk_individual_t ind;\n tsk_id_t ind_pop;\n const tsk_id_t *node_population = self->tables->nodes.population;\n const tsk_size_t num_individuals = self->tables->individuals.num_rows;\n\n tsk_memset(output, TSK_NULL, num_individuals * sizeof(*output));\n\n for (i = 0; i < num_individuals; i++) {\n ret = tsk_treeseq_get_individual(self, (tsk_id_t) i, &ind);\n tsk_bug_assert(ret == 0);\n if (ind.nodes_length > 0) {\n ind_pop = -2;\n for (j = 0; j < ind.nodes_length; j++) {\n if (ind_pop == -2) {\n ind_pop = node_population[ind.nodes[j]];\n } else if (ind_pop != node_population[ind.nodes[j]]) {\n ret = tsk_trace_error(TSK_ERR_INDIVIDUAL_POPULATION_MISMATCH);\n goto out;\n }\n }\n output[ind.id] = ind_pop;\n }\n }\nout:\n return ret;\n}\n\nint\ntsk_treeseq_get_individuals_time(const tsk_treeseq_t *self, double *output)\n{\n int ret = 0;\n tsk_size_t i, j;\n tsk_individual_t ind;\n double ind_time;\n const double *node_time = self->tables->nodes.time;\n const tsk_size_t num_individuals = self->tables->individuals.num_rows;\n\n for (i = 0; i < num_individuals; i++) {\n ret = tsk_treeseq_get_individual(self, (tsk_id_t) i, &ind);\n tsk_bug_assert(ret == 0);\n /* the default is UNKNOWN_TIME, but nodes cannot have\n * UNKNOWN _TIME so this is safe. */\n ind_time = TSK_UNKNOWN_TIME;\n for (j = 0; j < ind.nodes_length; j++) {\n if (j == 0) {\n ind_time = node_time[ind.nodes[j]];\n } else if (ind_time != node_time[ind.nodes[j]]) {\n ret = tsk_trace_error(TSK_ERR_INDIVIDUAL_TIME_MISMATCH);\n goto out;\n }\n }\n output[ind.id] = ind_time;\n }\nout:\n return ret;\n}\n\n/* Stats functions */\n\n#define GET_2D_ROW(array, row_len, row) (array + (((size_t) (row_len)) * (size_t) (row)))\n\nstatic inline double *\nGET_3D_ROW(double *base, tsk_size_t num_nodes, tsk_size_t output_dim,\n tsk_size_t window_index, tsk_id_t u)\n{\n tsk_size_t offset\n = window_index * num_nodes * output_dim + ((tsk_size_t) u) * output_dim;\n return base + offset;\n}\n\n/* Increments the n-dimensional array with the specified shape by the specified value at\n * the specified coordinate. */\nstatic inline void\nincrement_nd_array_value(double *array, tsk_size_t n, const tsk_size_t *shape,\n const tsk_size_t *coordinate, double value)\n{\n tsk_size_t offset = 0;\n tsk_size_t product = 1;\n int k;\n\n for (k = (int) n - 1; k >= 0; k--) {\n tsk_bug_assert(coordinate[k] < shape[k]);\n offset += coordinate[k] * product;\n product *= shape[k];\n }\n array[offset] += value;\n}\n\n/* TODO flatten the reference sets input here and follow the same pattern used\n * in diversity, divergence, etc. */\nint TSK_WARN_UNUSED\ntsk_treeseq_genealogical_nearest_neighbours(const tsk_treeseq_t *self,\n const tsk_id_t *focal, tsk_size_t num_focal, const tsk_id_t *const *reference_sets,\n const tsk_size_t *reference_set_size, tsk_size_t num_reference_sets,\n tsk_flags_t TSK_UNUSED(options), double *ret_array)\n{\n int ret = 0;\n tsk_id_t u, v, p;\n tsk_size_t j;\n /* TODO It's probably not worth bothering with the int16_t here. */\n int16_t k, focal_reference_set;\n /* We use the K'th element of the array for the total. */\n const int16_t K = (int16_t) (num_reference_sets + 1);\n tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const tsk_id_t num_edges = (tsk_id_t) self->tables->edges.num_rows;\n const tsk_id_t *restrict I = self->tables->indexes.edge_insertion_order;\n const tsk_id_t *restrict O = self->tables->indexes.edge_removal_order;\n const double *restrict edge_left = self->tables->edges.left;\n const double *restrict edge_right = self->tables->edges.right;\n const tsk_id_t *restrict edge_parent = self->tables->edges.parent;\n const tsk_id_t *restrict edge_child = self->tables->edges.child;\n const double sequence_length = self->tables->sequence_length;\n tsk_id_t tj, tk, h;\n double left, right, *A_row, scale, tree_length;\n tsk_id_t *restrict parent = tsk_malloc(num_nodes * sizeof(*parent));\n double *restrict length = tsk_calloc(num_focal, sizeof(*length));\n uint32_t *restrict ref_count\n = tsk_calloc(((tsk_size_t) K) * num_nodes, sizeof(*ref_count));\n int16_t *restrict reference_set_map\n = tsk_malloc(num_nodes * sizeof(*reference_set_map));\n uint32_t *restrict row = NULL;\n uint32_t *restrict child_row = NULL;\n uint32_t total, delta;\n\n /* We support a max of 8K focal sets */\n if (num_reference_sets == 0 || num_reference_sets > (INT16_MAX - 1)) {\n /* TODO: more specific error */\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if (parent == NULL || ref_count == NULL || reference_set_map == NULL\n || length == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n tsk_memset(parent, 0xff, num_nodes * sizeof(*parent));\n tsk_memset(reference_set_map, 0xff, num_nodes * sizeof(*reference_set_map));\n tsk_memset(ret_array, 0, num_focal * num_reference_sets * sizeof(*ret_array));\n\n total = 0; /* keep the compiler happy */\n\n /* Set the initial conditions and check the input. */\n for (k = 0; k < (int16_t) num_reference_sets; k++) {\n for (j = 0; j < reference_set_size[k]; j++) {\n u = reference_sets[k][j];\n if (u < 0 || u >= (tsk_id_t) num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n if (reference_set_map[u] != TSK_NULL) {\n /* FIXME Technically inaccurate here: duplicate focal not sample */\n ret = tsk_trace_error(TSK_ERR_DUPLICATE_SAMPLE);\n goto out;\n }\n reference_set_map[u] = k;\n row = GET_2D_ROW(ref_count, K, u);\n row[k] = 1;\n /* Also set the count for the total among all sets */\n row[K - 1] = 1;\n }\n }\n for (j = 0; j < num_focal; j++) {\n u = focal[j];\n if (u < 0 || u >= (tsk_id_t) num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n }\n\n /* Iterate over the trees */\n tj = 0;\n tk = 0;\n left = 0;\n while (tj < num_edges || left < sequence_length) {\n while (tk < num_edges && edge_right[O[tk]] == left) {\n h = O[tk];\n tk++;\n u = edge_child[h];\n v = edge_parent[h];\n parent[u] = TSK_NULL;\n child_row = GET_2D_ROW(ref_count, K, u);\n while (v != TSK_NULL) {\n row = GET_2D_ROW(ref_count, K, v);\n for (k = 0; k < K; k++) {\n row[k] -= child_row[k];\n }\n v = parent[v];\n }\n }\n while (tj < num_edges && edge_left[I[tj]] == left) {\n h = I[tj];\n tj++;\n u = edge_child[h];\n v = edge_parent[h];\n parent[u] = v;\n child_row = GET_2D_ROW(ref_count, K, u);\n while (v != TSK_NULL) {\n row = GET_2D_ROW(ref_count, K, v);\n for (k = 0; k < K; k++) {\n row[k] += child_row[k];\n }\n v = parent[v];\n }\n }\n right = sequence_length;\n if (tj < num_edges) {\n right = TSK_MIN(right, edge_left[I[tj]]);\n }\n if (tk < num_edges) {\n right = TSK_MIN(right, edge_right[O[tk]]);\n }\n\n tree_length = right - left;\n /* Process this tree */\n for (j = 0; j < num_focal; j++) {\n u = focal[j];\n focal_reference_set = reference_set_map[u];\n delta = focal_reference_set != -1;\n p = u;\n while (p != TSK_NULL) {\n row = GET_2D_ROW(ref_count, K, p);\n total = row[K - 1];\n if (total > delta) {\n break;\n }\n p = parent[p];\n }\n if (p != TSK_NULL) {\n length[j] += tree_length;\n scale = tree_length / (total - delta);\n A_row = GET_2D_ROW(ret_array, num_reference_sets, j);\n for (k = 0; k < K - 1; k++) {\n A_row[k] += row[k] * scale;\n }\n if (focal_reference_set != -1) {\n /* Remove the contribution for the reference set u belongs to and\n * insert the correct value. The long-hand version is\n * A_row[k] = A_row[k] - row[k] * scale + (row[k] - 1) * scale;\n * which cancels to give: */\n A_row[focal_reference_set] -= scale;\n }\n }\n }\n\n /* Move on to the next tree */\n left = right;\n }\n\n /* Divide by the accumulated length for each node to normalise */\n for (j = 0; j < num_focal; j++) {\n A_row = GET_2D_ROW(ret_array, num_reference_sets, j);\n if (length[j] > 0) {\n for (k = 0; k < K - 1; k++) {\n A_row[k] /= length[j];\n }\n }\n }\nout:\n /* Can't use msp_safe_free here because of restrict */\n if (parent != NULL) {\n free(parent);\n }\n if (ref_count != NULL) {\n free(ref_count);\n }\n if (reference_set_map != NULL) {\n free(reference_set_map);\n }\n if (length != NULL) {\n free(length);\n }\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_mean_descendants(const tsk_treeseq_t *self,\n const tsk_id_t *const *reference_sets, const tsk_size_t *reference_set_size,\n tsk_size_t num_reference_sets, tsk_flags_t TSK_UNUSED(options), double *ret_array)\n{\n int ret = 0;\n tsk_id_t u, v;\n tsk_size_t j;\n int32_t k;\n /* We use the K'th element of the array for the total. */\n const int32_t K = (int32_t) (num_reference_sets + 1);\n tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const tsk_id_t num_edges = (tsk_id_t) self->tables->edges.num_rows;\n const tsk_id_t *restrict I = self->tables->indexes.edge_insertion_order;\n const tsk_id_t *restrict O = self->tables->indexes.edge_removal_order;\n const double *restrict edge_left = self->tables->edges.left;\n const double *restrict edge_right = self->tables->edges.right;\n const tsk_id_t *restrict edge_parent = self->tables->edges.parent;\n const tsk_id_t *restrict edge_child = self->tables->edges.child;\n const double sequence_length = self->tables->sequence_length;\n tsk_id_t tj, tk, h;\n double left, right, length, *restrict C_row;\n tsk_id_t *restrict parent = tsk_malloc(num_nodes * sizeof(*parent));\n uint32_t *restrict ref_count\n = tsk_calloc(num_nodes * ((size_t) K), sizeof(*ref_count));\n double *restrict last_update = tsk_calloc(num_nodes, sizeof(*last_update));\n double *restrict total_length = tsk_calloc(num_nodes, sizeof(*total_length));\n uint32_t *restrict row, *restrict child_row;\n\n if (num_reference_sets == 0 || num_reference_sets > (INT32_MAX - 1)) {\n /* TODO: more specific error */\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n if (parent == NULL || ref_count == NULL || last_update == NULL\n || total_length == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n /* TODO add check for duplicate values in the reference sets */\n\n tsk_memset(parent, 0xff, num_nodes * sizeof(*parent));\n tsk_memset(ret_array, 0, num_nodes * num_reference_sets * sizeof(*ret_array));\n\n /* Set the initial conditions and check the input. */\n for (k = 0; k < (int32_t) num_reference_sets; k++) {\n for (j = 0; j < reference_set_size[k]; j++) {\n u = reference_sets[k][j];\n if (u < 0 || u >= (tsk_id_t) num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n row = GET_2D_ROW(ref_count, K, u);\n row[k] = 1;\n /* Also set the count for the total among all sets */\n row[K - 1] = 1;\n }\n }\n\n /* Iterate over the trees */\n tj = 0;\n tk = 0;\n left = 0;\n while (tj < num_edges || left < sequence_length) {\n while (tk < num_edges && edge_right[O[tk]] == left) {\n h = O[tk];\n tk++;\n u = edge_child[h];\n v = edge_parent[h];\n parent[u] = TSK_NULL;\n child_row = GET_2D_ROW(ref_count, K, u);\n while (v != TSK_NULL) {\n row = GET_2D_ROW(ref_count, K, v);\n if (last_update[v] != left) {\n if (row[K - 1] > 0) {\n length = left - last_update[v];\n C_row = GET_2D_ROW(ret_array, num_reference_sets, v);\n for (k = 0; k < (int32_t) num_reference_sets; k++) {\n C_row[k] += length * row[k];\n }\n total_length[v] += length;\n }\n last_update[v] = left;\n }\n for (k = 0; k < K; k++) {\n row[k] -= child_row[k];\n }\n v = parent[v];\n }\n }\n while (tj < num_edges && edge_left[I[tj]] == left) {\n h = I[tj];\n tj++;\n u = edge_child[h];\n v = edge_parent[h];\n parent[u] = v;\n child_row = GET_2D_ROW(ref_count, K, u);\n while (v != TSK_NULL) {\n row = GET_2D_ROW(ref_count, K, v);\n if (last_update[v] != left) {\n if (row[K - 1] > 0) {\n length = left - last_update[v];\n C_row = GET_2D_ROW(ret_array, num_reference_sets, v);\n for (k = 0; k < (int32_t) num_reference_sets; k++) {\n C_row[k] += length * row[k];\n }\n total_length[v] += length;\n }\n last_update[v] = left;\n }\n for (k = 0; k < K; k++) {\n row[k] += child_row[k];\n }\n v = parent[v];\n }\n }\n right = sequence_length;\n if (tj < num_edges) {\n right = TSK_MIN(right, edge_left[I[tj]]);\n }\n if (tk < num_edges) {\n right = TSK_MIN(right, edge_right[O[tk]]);\n }\n left = right;\n }\n\n /* Add the stats for the last tree and divide by the total length that\n * each node was an ancestor to > 0 of the reference nodes. */\n for (v = 0; v < (tsk_id_t) num_nodes; v++) {\n row = GET_2D_ROW(ref_count, K, v);\n C_row = GET_2D_ROW(ret_array, num_reference_sets, v);\n if (row[K - 1] > 0) {\n length = sequence_length - last_update[v];\n total_length[v] += length;\n for (k = 0; k < (int32_t) num_reference_sets; k++) {\n C_row[k] += length * row[k];\n }\n }\n if (total_length[v] > 0) {\n length = total_length[v];\n for (k = 0; k < (int32_t) num_reference_sets; k++) {\n C_row[k] /= length;\n }\n }\n }\n\nout:\n /* Can't use msp_safe_free here because of restrict */\n if (parent != NULL) {\n free(parent);\n }\n if (ref_count != NULL) {\n free(ref_count);\n }\n if (last_update != NULL) {\n free(last_update);\n }\n if (total_length != NULL) {\n free(total_length);\n }\n return ret;\n}\n\n/***********************************\n * General stats framework\n ***********************************/\n\n#define TSK_REQUIRE_FULL_SPAN 1\n\nstatic int\ntsk_treeseq_check_windows(const tsk_treeseq_t *self, tsk_size_t num_windows,\n const double *windows, tsk_flags_t options)\n{\n int ret = 0;\n tsk_size_t j;\n\n if (num_windows < 1) {\n ret = tsk_trace_error(TSK_ERR_BAD_NUM_WINDOWS);\n goto out;\n }\n if (options & TSK_REQUIRE_FULL_SPAN) {\n /* TODO the general stat code currently requires that we include the\n * entire tree sequence span. This should be relaxed, so hopefully\n * this branch (and the option) can be removed at some point */\n if (windows[0] != 0) {\n ret = tsk_trace_error(TSK_ERR_BAD_WINDOWS);\n goto out;\n }\n if (windows[num_windows] != self->tables->sequence_length) {\n ret = tsk_trace_error(TSK_ERR_BAD_WINDOWS);\n goto out;\n }\n } else {\n if (windows[0] < 0) {\n ret = tsk_trace_error(TSK_ERR_BAD_WINDOWS);\n goto out;\n }\n if (windows[num_windows] > self->tables->sequence_length) {\n ret = tsk_trace_error(TSK_ERR_BAD_WINDOWS);\n goto out;\n }\n }\n for (j = 0; j < num_windows; j++) {\n if (windows[j] >= windows[j + 1]) {\n ret = tsk_trace_error(TSK_ERR_BAD_WINDOWS);\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nstatic int\ntsk_treeseq_check_time_windows(tsk_size_t num_windows, const double *windows)\n{\n // This does not check the last window ends at infinity,\n // which is required for some time window functions.\n int ret = TSK_ERR_BAD_TIME_WINDOWS;\n tsk_size_t j;\n\n if (num_windows < 1) {\n ret = TSK_ERR_BAD_TIME_WINDOWS_DIM;\n goto out;\n }\n\n if (windows[0] != 0.0) {\n goto out;\n }\n\n for (j = 0; j < num_windows; j++) {\n if (windows[j] >= windows[j + 1]) {\n goto out;\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\n/* TODO make these functions more consistent in how the arguments are ordered */\n\nstatic inline void\nupdate_state(double *X, tsk_size_t state_dim, tsk_id_t dest, tsk_id_t source, int sign)\n{\n tsk_size_t k;\n double *X_dest = GET_2D_ROW(X, state_dim, dest);\n double *X_source = GET_2D_ROW(X, state_dim, source);\n\n for (k = 0; k < state_dim; k++) {\n X_dest[k] += sign * X_source[k];\n }\n}\n\nstatic inline int\nupdate_node_summary(tsk_id_t u, tsk_size_t result_dim, double *node_summary, double *X,\n tsk_size_t state_dim, general_stat_func_t *f, void *f_params)\n{\n double *X_u = GET_2D_ROW(X, state_dim, u);\n double *summary_u = GET_2D_ROW(node_summary, result_dim, u);\n\n return f(state_dim, X_u, result_dim, summary_u, f_params);\n}\n\nstatic inline void\nupdate_running_sum(tsk_id_t u, double sign, const double *restrict branch_length,\n const double *summary, tsk_size_t result_dim, double *running_sum)\n{\n const double *summary_u = GET_2D_ROW(summary, result_dim, u);\n const double x = sign * branch_length[u];\n tsk_size_t m;\n\n for (m = 0; m < result_dim; m++) {\n running_sum[m] += x * summary_u[m];\n }\n}\n\nstatic int\ntsk_treeseq_branch_general_stat(const tsk_treeseq_t *self, tsk_size_t state_dim,\n const double *sample_weights, tsk_size_t result_dim, general_stat_func_t *f,\n void *f_params, tsk_size_t num_windows, const double *windows, tsk_flags_t options,\n double *result)\n{\n int ret = 0;\n tsk_id_t u, v;\n tsk_size_t j, k, window_index;\n tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const tsk_id_t num_edges = (tsk_id_t) self->tables->edges.num_rows;\n const tsk_id_t *restrict I = self->tables->indexes.edge_insertion_order;\n const tsk_id_t *restrict O = self->tables->indexes.edge_removal_order;\n const double *restrict edge_left = self->tables->edges.left;\n const double *restrict edge_right = self->tables->edges.right;\n const tsk_id_t *restrict edge_parent = self->tables->edges.parent;\n const tsk_id_t *restrict edge_child = self->tables->edges.child;\n const double *restrict time = self->tables->nodes.time;\n const double sequence_length = self->tables->sequence_length;\n tsk_id_t *restrict parent = tsk_malloc(num_nodes * sizeof(*parent));\n double *restrict branch_length = tsk_calloc(num_nodes, sizeof(*branch_length));\n tsk_id_t tj, tk, h;\n double t_left, t_right, w_left, w_right, left, right, scale;\n const double *weight_u;\n double *state_u, *result_row, *summary_u;\n double *state = tsk_calloc(num_nodes * state_dim, sizeof(*state));\n double *summary = tsk_calloc(num_nodes * result_dim, sizeof(*summary));\n double *running_sum = tsk_calloc(result_dim, sizeof(*running_sum));\n double *zero_state = tsk_calloc(state_dim, sizeof(*zero_state));\n double *zero_summary = tsk_calloc(result_dim, sizeof(*zero_state));\n\n if (self->time_uncalibrated && !(options & TSK_STAT_ALLOW_TIME_UNCALIBRATED)) {\n ret = tsk_trace_error(TSK_ERR_TIME_UNCALIBRATED);\n goto out;\n }\n\n if (parent == NULL || branch_length == NULL || state == NULL || running_sum == NULL\n || summary == NULL || zero_state == NULL || zero_summary == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(parent, 0xff, num_nodes * sizeof(*parent));\n\n /* If f is not strict, we may need to set conditions for non-sample nodes as well. */\n ret = f(state_dim, zero_state, result_dim, zero_summary, f_params);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_nodes; j++) { // we could skip this if zero_summary is zero\n summary_u = GET_2D_ROW(summary, result_dim, j);\n tsk_memcpy(summary_u, zero_summary, result_dim * sizeof(*zero_summary));\n }\n /* Set the initial conditions */\n for (j = 0; j < self->num_samples; j++) {\n u = self->samples[j];\n state_u = GET_2D_ROW(state, state_dim, u);\n weight_u = GET_2D_ROW(sample_weights, state_dim, j);\n tsk_memcpy(state_u, weight_u, state_dim * sizeof(*state_u));\n summary_u = GET_2D_ROW(summary, result_dim, u);\n ret = f(state_dim, state_u, result_dim, summary_u, f_params);\n if (ret != 0) {\n goto out;\n }\n }\n\n tsk_memset(result, 0, num_windows * result_dim * sizeof(*result));\n\n /* Iterate over the trees */\n tj = 0;\n tk = 0;\n t_left = 0;\n window_index = 0;\n while (tj < num_edges || t_left < sequence_length) {\n while (tk < num_edges && edge_right[O[tk]] == t_left) {\n h = O[tk];\n tk++;\n\n u = edge_child[h];\n update_running_sum(u, -1, branch_length, summary, result_dim, running_sum);\n parent[u] = TSK_NULL;\n branch_length[u] = 0;\n\n u = edge_parent[h];\n while (u != TSK_NULL) {\n update_running_sum(\n u, -1, branch_length, summary, result_dim, running_sum);\n update_state(state, state_dim, u, edge_child[h], -1);\n ret = update_node_summary(\n u, result_dim, summary, state, state_dim, f, f_params);\n if (ret != 0) {\n goto out;\n }\n update_running_sum(\n u, +1, branch_length, summary, result_dim, running_sum);\n u = parent[u];\n }\n }\n\n while (tj < num_edges && edge_left[I[tj]] == t_left) {\n h = I[tj];\n tj++;\n\n u = edge_child[h];\n v = edge_parent[h];\n parent[u] = v;\n branch_length[u] = time[v] - time[u];\n update_running_sum(u, +1, branch_length, summary, result_dim, running_sum);\n\n u = v;\n while (u != TSK_NULL) {\n update_running_sum(\n u, -1, branch_length, summary, result_dim, running_sum);\n update_state(state, state_dim, u, edge_child[h], +1);\n ret = update_node_summary(\n u, result_dim, summary, state, state_dim, f, f_params);\n if (ret != 0) {\n goto out;\n }\n update_running_sum(\n u, +1, branch_length, summary, result_dim, running_sum);\n u = parent[u];\n }\n }\n\n t_right = sequence_length;\n if (tj < num_edges) {\n t_right = TSK_MIN(t_right, edge_left[I[tj]]);\n }\n if (tk < num_edges) {\n t_right = TSK_MIN(t_right, edge_right[O[tk]]);\n }\n\n while (windows[window_index] < t_right) {\n tsk_bug_assert(window_index < num_windows);\n w_left = windows[window_index];\n w_right = windows[window_index + 1];\n left = TSK_MAX(t_left, w_left);\n right = TSK_MIN(t_right, w_right);\n scale = (right - left);\n tsk_bug_assert(scale > 0);\n result_row = GET_2D_ROW(result, result_dim, window_index);\n for (k = 0; k < result_dim; k++) {\n result_row[k] += running_sum[k] * scale;\n }\n\n if (w_right <= t_right) {\n window_index++;\n } else {\n /* This interval crosses a tree boundary, so we update it again in the */\n /* for the next tree */\n break;\n }\n }\n /* Move to the next tree */\n t_left = t_right;\n }\n tsk_bug_assert(window_index == num_windows);\nout:\n /* Can't use msp_safe_free here because of restrict */\n if (parent != NULL) {\n free(parent);\n }\n if (branch_length != NULL) {\n free(branch_length);\n }\n tsk_safe_free(state);\n tsk_safe_free(summary);\n tsk_safe_free(running_sum);\n tsk_safe_free(zero_state);\n tsk_safe_free(zero_summary);\n return ret;\n}\n\nstatic int\nget_allele_weights(const tsk_site_t *site, const double *state, tsk_size_t state_dim,\n const double *total_weight, tsk_size_t *ret_num_alleles, double **ret_allele_states)\n{\n int ret = 0;\n tsk_size_t k;\n tsk_mutation_t mutation, parent_mut;\n tsk_size_t mutation_index, allele, num_alleles, alt_allele_length;\n /* The allele table */\n tsk_size_t max_alleles = site->mutations_length + 1;\n const char **alleles = tsk_malloc(max_alleles * sizeof(*alleles));\n tsk_size_t *allele_lengths = tsk_calloc(max_alleles, sizeof(*allele_lengths));\n double *allele_states = tsk_calloc(max_alleles * state_dim, sizeof(*allele_states));\n double *allele_row;\n const double *state_row;\n const char *alt_allele;\n\n if (alleles == NULL || allele_lengths == NULL || allele_states == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n tsk_bug_assert(state != NULL);\n alleles[0] = site->ancestral_state;\n allele_lengths[0] = site->ancestral_state_length;\n tsk_memcpy(allele_states, total_weight, state_dim * sizeof(*allele_states));\n num_alleles = 1;\n\n for (mutation_index = 0; mutation_index < site->mutations_length; mutation_index++) {\n mutation = site->mutations[mutation_index];\n /* Compute the allele index for this derived state value. */\n allele = 0;\n while (allele < num_alleles) {\n if (mutation.derived_state_length == allele_lengths[allele]\n && tsk_memcmp(\n mutation.derived_state, alleles[allele], allele_lengths[allele])\n == 0) {\n break;\n }\n allele++;\n }\n if (allele == num_alleles) {\n tsk_bug_assert(allele < max_alleles);\n alleles[allele] = mutation.derived_state;\n allele_lengths[allele] = mutation.derived_state_length;\n num_alleles++;\n }\n\n /* Add the state for the the mutation's node to this allele */\n state_row = GET_2D_ROW(state, state_dim, mutation.node);\n allele_row = GET_2D_ROW(allele_states, state_dim, allele);\n for (k = 0; k < state_dim; k++) {\n allele_row[k] += state_row[k];\n }\n\n /* Get the index for the alternate allele that we must subtract from */\n alt_allele = site->ancestral_state;\n alt_allele_length = site->ancestral_state_length;\n if (mutation.parent != TSK_NULL) {\n parent_mut = site->mutations[mutation.parent - site->mutations[0].id];\n alt_allele = parent_mut.derived_state;\n alt_allele_length = parent_mut.derived_state_length;\n }\n allele = 0;\n while (allele < num_alleles) {\n if (alt_allele_length == allele_lengths[allele]\n && tsk_memcmp(alt_allele, alleles[allele], allele_lengths[allele])\n == 0) {\n break;\n }\n allele++;\n }\n tsk_bug_assert(allele < num_alleles);\n\n allele_row = GET_2D_ROW(allele_states, state_dim, allele);\n for (k = 0; k < state_dim; k++) {\n allele_row[k] -= state_row[k];\n }\n }\n *ret_num_alleles = num_alleles;\n *ret_allele_states = allele_states;\n allele_states = NULL;\nout:\n tsk_safe_free(alleles);\n tsk_safe_free(allele_lengths);\n tsk_safe_free(allele_states);\n return ret;\n}\n\nstatic int\ncompute_general_stat_site_result(tsk_site_t *site, double *state, tsk_size_t state_dim,\n tsk_size_t result_dim, general_stat_func_t *f, void *f_params, double *total_weight,\n bool polarised, double *result)\n{\n int ret = 0;\n tsk_size_t k;\n tsk_size_t allele, num_alleles;\n double *allele_states;\n double *result_tmp = tsk_calloc(result_dim, sizeof(*result_tmp));\n\n if (result_tmp == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(result, 0, result_dim * sizeof(*result));\n\n ret = get_allele_weights(\n site, state, state_dim, total_weight, &num_alleles, &allele_states);\n if (ret != 0) {\n goto out;\n }\n /* Sum over the allele weights. Skip the ancestral state if this is a polarised stat\n */\n for (allele = polarised ? 1 : 0; allele < num_alleles; allele++) {\n ret = f(state_dim, GET_2D_ROW(allele_states, state_dim, allele), result_dim,\n result_tmp, f_params);\n if (ret != 0) {\n goto out;\n }\n for (k = 0; k < result_dim; k++) {\n result[k] += result_tmp[k];\n }\n }\nout:\n tsk_safe_free(result_tmp);\n tsk_safe_free(allele_states);\n return ret;\n}\n\nstatic int\ntsk_treeseq_site_general_stat(const tsk_treeseq_t *self, tsk_size_t state_dim,\n const double *sample_weights, tsk_size_t result_dim, general_stat_func_t *f,\n void *f_params, tsk_size_t num_windows, const double *windows, tsk_flags_t options,\n double *result)\n{\n int ret = 0;\n tsk_id_t u, v;\n tsk_size_t j, k, tree_site, tree_index, window_index;\n tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const tsk_id_t num_edges = (tsk_id_t) self->tables->edges.num_rows;\n const tsk_id_t *restrict I = self->tables->indexes.edge_insertion_order;\n const tsk_id_t *restrict O = self->tables->indexes.edge_removal_order;\n const double *restrict edge_left = self->tables->edges.left;\n const double *restrict edge_right = self->tables->edges.right;\n const tsk_id_t *restrict edge_parent = self->tables->edges.parent;\n const tsk_id_t *restrict edge_child = self->tables->edges.child;\n const double sequence_length = self->tables->sequence_length;\n tsk_id_t *restrict parent = tsk_malloc(num_nodes * sizeof(*parent));\n tsk_site_t *site;\n tsk_id_t tj, tk, h;\n double t_left, t_right;\n const double *weight_u;\n double *state_u, *result_row;\n double *state = tsk_calloc(num_nodes * state_dim, sizeof(*state));\n double *total_weight = tsk_calloc(state_dim, sizeof(*total_weight));\n double *site_result = tsk_calloc(result_dim, sizeof(*site_result));\n bool polarised = false;\n\n if (parent == NULL || state == NULL || total_weight == NULL || site_result == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(parent, 0xff, num_nodes * sizeof(*parent));\n\n if (options & TSK_STAT_POLARISED) {\n polarised = true;\n }\n\n /* Set the initial conditions */\n for (j = 0; j < self->num_samples; j++) {\n u = self->samples[j];\n state_u = GET_2D_ROW(state, state_dim, u);\n weight_u = GET_2D_ROW(sample_weights, state_dim, j);\n tsk_memcpy(state_u, weight_u, state_dim * sizeof(*state_u));\n for (k = 0; k < state_dim; k++) {\n total_weight[k] += weight_u[k];\n }\n }\n tsk_memset(result, 0, num_windows * result_dim * sizeof(*result));\n\n /* Iterate over the trees */\n tj = 0;\n tk = 0;\n t_left = 0;\n tree_index = 0;\n window_index = 0;\n while (tj < num_edges || t_left < sequence_length) {\n while (tk < num_edges && edge_right[O[tk]] == t_left) {\n h = O[tk];\n tk++;\n u = edge_child[h];\n v = edge_parent[h];\n while (v != TSK_NULL) {\n update_state(state, state_dim, v, u, -1);\n v = parent[v];\n }\n parent[u] = TSK_NULL;\n }\n\n while (tj < num_edges && edge_left[I[tj]] == t_left) {\n h = I[tj];\n tj++;\n u = edge_child[h];\n v = edge_parent[h];\n parent[u] = v;\n while (v != TSK_NULL) {\n update_state(state, state_dim, v, u, +1);\n v = parent[v];\n }\n }\n t_right = sequence_length;\n if (tj < num_edges) {\n t_right = TSK_MIN(t_right, edge_left[I[tj]]);\n }\n if (tk < num_edges) {\n t_right = TSK_MIN(t_right, edge_right[O[tk]]);\n }\n\n /* Update the sites */\n for (tree_site = 0; tree_site < self->tree_sites_length[tree_index];\n tree_site++) {\n site = self->tree_sites[tree_index] + tree_site;\n ret = compute_general_stat_site_result(site, state, state_dim, result_dim, f,\n f_params, total_weight, polarised, site_result);\n if (ret != 0) {\n goto out;\n }\n\n while (windows[window_index + 1] <= site->position) {\n window_index++;\n tsk_bug_assert(window_index < num_windows);\n }\n tsk_bug_assert(windows[window_index] <= site->position);\n tsk_bug_assert(site->position < windows[window_index + 1]);\n result_row = GET_2D_ROW(result, result_dim, window_index);\n for (k = 0; k < result_dim; k++) {\n result_row[k] += site_result[k];\n }\n }\n tree_index++;\n t_left = t_right;\n }\nout:\n /* Can't use msp_safe_free here because of restrict */\n if (parent != NULL) {\n free(parent);\n }\n tsk_safe_free(state);\n tsk_safe_free(total_weight);\n tsk_safe_free(site_result);\n return ret;\n}\n\nstatic inline void\nincrement_row(tsk_size_t length, double multiplier, double *source, double *dest)\n{\n tsk_size_t j;\n\n for (j = 0; j < length; j++) {\n dest[j] += multiplier * source[j];\n }\n}\n\nstatic int\ntsk_treeseq_node_general_stat(const tsk_treeseq_t *self, tsk_size_t state_dim,\n const double *sample_weights, tsk_size_t result_dim, general_stat_func_t *f,\n void *f_params, tsk_size_t num_windows, const double *windows,\n tsk_flags_t TSK_UNUSED(options), double *result)\n{\n int ret = 0;\n tsk_id_t u, v;\n tsk_size_t j, window_index;\n tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const tsk_id_t num_edges = (tsk_id_t) self->tables->edges.num_rows;\n const tsk_id_t *restrict I = self->tables->indexes.edge_insertion_order;\n const tsk_id_t *restrict O = self->tables->indexes.edge_removal_order;\n const double *restrict edge_left = self->tables->edges.left;\n const double *restrict edge_right = self->tables->edges.right;\n const tsk_id_t *restrict edge_parent = self->tables->edges.parent;\n const tsk_id_t *restrict edge_child = self->tables->edges.child;\n const double sequence_length = self->tables->sequence_length;\n tsk_id_t *restrict parent = tsk_malloc(num_nodes * sizeof(*parent));\n tsk_id_t tj, tk, h;\n const double *weight_u;\n double *state_u;\n double *state = tsk_calloc(num_nodes * state_dim, sizeof(*state));\n double *node_summary = tsk_calloc(num_nodes * result_dim, sizeof(*node_summary));\n double *last_update = tsk_calloc(num_nodes, sizeof(*last_update));\n double t_left, t_right, w_right;\n\n if (parent == NULL || state == NULL || node_summary == NULL || last_update == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(parent, 0xff, num_nodes * sizeof(*parent));\n tsk_memset(result, 0, num_windows * num_nodes * result_dim * sizeof(*result));\n\n /* Set the initial conditions */\n for (j = 0; j < self->num_samples; j++) {\n u = self->samples[j];\n state_u = GET_2D_ROW(state, state_dim, u);\n weight_u = GET_2D_ROW(sample_weights, state_dim, j);\n tsk_memcpy(state_u, weight_u, state_dim * sizeof(*state_u));\n }\n for (u = 0; u < (tsk_id_t) num_nodes; u++) {\n ret = update_node_summary(\n u, result_dim, node_summary, state, state_dim, f, f_params);\n if (ret != 0) {\n goto out;\n }\n }\n\n /* Iterate over the trees */\n tj = 0;\n tk = 0;\n t_left = 0;\n window_index = 0;\n while (tj < num_edges || t_left < sequence_length) {\n tsk_bug_assert(window_index < num_windows);\n while (tk < num_edges && edge_right[O[tk]] == t_left) {\n h = O[tk];\n tk++;\n u = edge_child[h];\n v = edge_parent[h];\n while (v != TSK_NULL) {\n increment_row(result_dim, t_left - last_update[v],\n GET_2D_ROW(node_summary, result_dim, v),\n GET_3D_ROW(result, num_nodes, result_dim, window_index, v));\n last_update[v] = t_left;\n update_state(state, state_dim, v, u, -1);\n ret = update_node_summary(\n v, result_dim, node_summary, state, state_dim, f, f_params);\n if (ret != 0) {\n goto out;\n }\n v = parent[v];\n }\n parent[u] = TSK_NULL;\n }\n\n while (tj < num_edges && edge_left[I[tj]] == t_left) {\n h = I[tj];\n tj++;\n u = edge_child[h];\n v = edge_parent[h];\n parent[u] = v;\n while (v != TSK_NULL) {\n increment_row(result_dim, t_left - last_update[v],\n GET_2D_ROW(node_summary, result_dim, v),\n GET_3D_ROW(result, num_nodes, result_dim, window_index, v));\n last_update[v] = t_left;\n update_state(state, state_dim, v, u, +1);\n ret = update_node_summary(\n v, result_dim, node_summary, state, state_dim, f, f_params);\n if (ret != 0) {\n goto out;\n }\n v = parent[v];\n }\n }\n\n t_right = sequence_length;\n if (tj < num_edges) {\n t_right = TSK_MIN(t_right, edge_left[I[tj]]);\n }\n if (tk < num_edges) {\n t_right = TSK_MIN(t_right, edge_right[O[tk]]);\n }\n\n while (window_index < num_windows && windows[window_index + 1] <= t_right) {\n w_right = windows[window_index + 1];\n /* Flush the contributions of all nodes to the current window */\n for (u = 0; u < (tsk_id_t) num_nodes; u++) {\n tsk_bug_assert(last_update[u] < w_right);\n increment_row(result_dim, w_right - last_update[u],\n GET_2D_ROW(node_summary, result_dim, u),\n GET_3D_ROW(result, num_nodes, result_dim, window_index, u));\n last_update[u] = w_right;\n }\n window_index++;\n }\n\n t_left = t_right;\n }\nout:\n /* Can't use msp_safe_free here because of restrict */\n if (parent != NULL) {\n free(parent);\n }\n tsk_safe_free(state);\n tsk_safe_free(node_summary);\n tsk_safe_free(last_update);\n return ret;\n}\n\nstatic void\nspan_normalise(\n tsk_size_t num_windows, const double *windows, tsk_size_t row_size, double *array)\n{\n tsk_size_t window_index, k;\n double span, *row;\n\n for (window_index = 0; window_index < num_windows; window_index++) {\n span = windows[window_index + 1] - windows[window_index];\n row = GET_2D_ROW(array, row_size, window_index);\n for (k = 0; k < row_size; k++) {\n row[k] /= span;\n }\n }\n}\n\ntypedef struct {\n general_stat_func_t *f;\n void *f_params;\n double *total_weight;\n double *total_minus_state;\n double *result_tmp;\n} unpolarised_summary_func_args;\n\nstatic int\nunpolarised_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t result_dim, double *result, void *params)\n{\n int ret = 0;\n unpolarised_summary_func_args *upargs = (unpolarised_summary_func_args *) params;\n const double *total_weight = upargs->total_weight;\n double *total_minus_state = upargs->total_minus_state;\n double *result_tmp = upargs->result_tmp;\n tsk_size_t k, m;\n\n ret = upargs->f(state_dim, state, result_dim, result, upargs->f_params);\n if (ret != 0) {\n goto out;\n }\n for (k = 0; k < state_dim; k++) {\n total_minus_state[k] = total_weight[k] - state[k];\n }\n ret = upargs->f(\n state_dim, total_minus_state, result_dim, result_tmp, upargs->f_params);\n if (ret != 0) {\n goto out;\n }\n for (m = 0; m < result_dim; m++) {\n result[m] += result_tmp[m];\n }\nout:\n return ret;\n}\n\n/* Abstracts the running of node and branch stats where the summary function\n * is run twice when non-polarised. We replace the call to the input summary\n * function with a call of the required form when non-polarised, simplifying\n * the implementation and memory management for the node and branch stats.\n */\nstatic int\ntsk_polarisable_func_general_stat(const tsk_treeseq_t *self, tsk_size_t state_dim,\n const double *sample_weights, tsk_size_t result_dim, general_stat_func_t *f,\n void *f_params, tsk_size_t num_windows, const double *windows, tsk_flags_t options,\n double *result)\n{\n int ret = 0;\n bool stat_branch = !!(options & TSK_STAT_BRANCH);\n bool polarised = options & TSK_STAT_POLARISED;\n general_stat_func_t *wrapped_f = f;\n void *wrapped_f_params = f_params;\n const double *weight_u;\n unpolarised_summary_func_args upargs;\n tsk_size_t j, k;\n\n tsk_memset(&upargs, 0, sizeof(upargs));\n if (!polarised) {\n upargs.f = f;\n upargs.f_params = f_params;\n upargs.total_weight = tsk_calloc(state_dim, sizeof(double));\n upargs.total_minus_state = tsk_calloc(state_dim, sizeof(double));\n upargs.result_tmp = tsk_calloc(result_dim, sizeof(double));\n\n if (upargs.total_weight == NULL || upargs.total_minus_state == NULL\n || upargs.result_tmp == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n /* Compute the total weight */\n for (j = 0; j < self->num_samples; j++) {\n weight_u = GET_2D_ROW(sample_weights, state_dim, j);\n for (k = 0; k < state_dim; k++) {\n upargs.total_weight[k] += weight_u[k];\n }\n }\n\n wrapped_f = unpolarised_summary_func;\n wrapped_f_params = &upargs;\n }\n\n if (stat_branch) {\n ret = tsk_treeseq_branch_general_stat(self, state_dim, sample_weights,\n result_dim, wrapped_f, wrapped_f_params, num_windows, windows, options,\n result);\n } else {\n ret = tsk_treeseq_node_general_stat(self, state_dim, sample_weights, result_dim,\n wrapped_f, wrapped_f_params, num_windows, windows, options, result);\n }\nout:\n tsk_safe_free(upargs.total_weight);\n tsk_safe_free(upargs.total_minus_state);\n tsk_safe_free(upargs.result_tmp);\n return ret;\n}\n\nint\ntsk_treeseq_general_stat(const tsk_treeseq_t *self, tsk_size_t state_dim,\n const double *sample_weights, tsk_size_t result_dim, general_stat_func_t *f,\n void *f_params, tsk_size_t num_windows, const double *windows, tsk_flags_t options,\n double *result)\n{\n int ret = 0;\n bool stat_site = !!(options & TSK_STAT_SITE);\n bool stat_branch = !!(options & TSK_STAT_BRANCH);\n bool stat_node = !!(options & TSK_STAT_NODE);\n double default_windows[] = { 0, self->tables->sequence_length };\n tsk_size_t row_size;\n\n /* If no mode is specified, we default to site mode */\n if (!(stat_site || stat_branch || stat_node)) {\n stat_site = true;\n }\n /* It's an error to specify more than one mode */\n if (stat_site + stat_branch + stat_node > 1) {\n ret = tsk_trace_error(TSK_ERR_MULTIPLE_STAT_MODES);\n goto out;\n }\n\n if (state_dim < 1) {\n ret = tsk_trace_error(TSK_ERR_BAD_STATE_DIMS);\n goto out;\n }\n if (result_dim < 1) {\n ret = tsk_trace_error(TSK_ERR_BAD_RESULT_DIMS);\n goto out;\n }\n if (windows == NULL) {\n num_windows = 1;\n windows = default_windows;\n } else {\n ret = tsk_treeseq_check_windows(\n self, num_windows, windows, TSK_REQUIRE_FULL_SPAN);\n if (ret != 0) {\n goto out;\n }\n }\n\n if (stat_site) {\n ret = tsk_treeseq_site_general_stat(self, state_dim, sample_weights, result_dim,\n f, f_params, num_windows, windows, options, result);\n } else {\n ret = tsk_polarisable_func_general_stat(self, state_dim, sample_weights,\n result_dim, f, f_params, num_windows, windows, options, result);\n }\n\n if (options & TSK_STAT_SPAN_NORMALISE) {\n row_size = result_dim;\n if (stat_node) {\n row_size = result_dim * tsk_treeseq_get_num_nodes(self);\n }\n span_normalise(num_windows, windows, row_size, result);\n }\n\nout:\n return ret;\n}\n\nstatic int\ncheck_set_indexes(\n tsk_size_t num_sets, tsk_size_t num_set_indexes, const tsk_id_t *set_indexes)\n{\n int ret = 0;\n tsk_size_t j;\n\n for (j = 0; j < num_set_indexes; j++) {\n if (set_indexes[j] < 0 || set_indexes[j] >= (tsk_id_t) num_sets) {\n ret = tsk_trace_error(TSK_ERR_BAD_SAMPLE_SET_INDEX);\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int\ntsk_treeseq_check_sample_sets(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets)\n{\n int ret = 0;\n tsk_size_t j, k, l;\n const tsk_id_t num_nodes = (tsk_id_t) self->tables->nodes.num_rows;\n tsk_id_t u, sample_index;\n\n if (num_sample_sets == 0) {\n ret = tsk_trace_error(TSK_ERR_INSUFFICIENT_SAMPLE_SETS);\n goto out;\n }\n j = 0;\n for (k = 0; k < num_sample_sets; k++) {\n if (sample_set_sizes[k] == 0) {\n ret = tsk_trace_error(TSK_ERR_EMPTY_SAMPLE_SET);\n goto out;\n }\n for (l = 0; l < sample_set_sizes[k]; l++) {\n u = sample_sets[j];\n if (u < 0 || u >= num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n sample_index = self->sample_index_map[u];\n if (sample_index == TSK_NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_SAMPLES);\n goto out;\n }\n j++;\n }\n }\nout:\n return ret;\n}\n\ntypedef struct {\n tsk_size_t num_samples;\n} weight_stat_params_t;\n\ntypedef struct {\n tsk_size_t num_samples;\n tsk_size_t num_covariates;\n double *V;\n} covariates_stat_params_t;\n\ntypedef struct {\n const tsk_id_t *sample_sets;\n tsk_size_t num_sample_sets;\n const tsk_size_t *sample_set_sizes;\n const tsk_id_t *set_indexes;\n} sample_count_stat_params_t;\n\ntypedef struct {\n tsk_size_t num_samples;\n double *total_weights;\n const tsk_id_t *index_tuples;\n} indexed_weight_stat_params_t;\n\nstatic int\ntsk_treeseq_sample_count_stat(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t result_dim, const tsk_id_t *set_indexes, general_stat_func_t *f,\n tsk_size_t num_windows, const double *windows, tsk_flags_t options, double *result)\n{\n int ret = 0;\n const tsk_size_t num_samples = self->num_samples;\n tsk_size_t j, k, l;\n tsk_id_t u, sample_index;\n double *weights = NULL;\n double *weight_row;\n sample_count_stat_params_t args = { .sample_sets = sample_sets,\n .num_sample_sets = num_sample_sets,\n .sample_set_sizes = sample_set_sizes,\n .set_indexes = set_indexes };\n\n ret = tsk_treeseq_check_sample_sets(\n self, num_sample_sets, sample_set_sizes, sample_sets);\n if (ret != 0) {\n goto out;\n }\n weights = tsk_calloc(num_samples * num_sample_sets, sizeof(*weights));\n if (weights == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n j = 0;\n for (k = 0; k < num_sample_sets; k++) {\n for (l = 0; l < sample_set_sizes[k]; l++) {\n u = sample_sets[j];\n sample_index = self->sample_index_map[u];\n weight_row = GET_2D_ROW(weights, num_sample_sets, sample_index);\n if (weight_row[k] != 0) {\n ret = tsk_trace_error(TSK_ERR_DUPLICATE_SAMPLE);\n goto out;\n }\n weight_row[k] = 1;\n j++;\n }\n }\n ret = tsk_treeseq_general_stat(self, num_sample_sets, weights, result_dim, f, &args,\n num_windows, windows, options, result);\nout:\n tsk_safe_free(weights);\n return ret;\n}\n\n/***********************************\n * Two Locus Statistics\n ***********************************/\n\nstatic int\nget_allele_samples(const tsk_site_t *site, tsk_size_t site_offset,\n const tsk_bitset_t *state, tsk_bitset_t *out_allele_samples,\n tsk_size_t *out_num_alleles)\n{\n int ret = 0;\n tsk_mutation_t mutation, parent_mut;\n tsk_size_t mutation_index, allele, alt_allele, alt_allele_length;\n /* The allele table */\n tsk_size_t max_alleles = site->mutations_length + 1;\n const char **alleles = tsk_malloc(max_alleles * sizeof(*alleles));\n tsk_size_t *allele_lengths = tsk_calloc(max_alleles, sizeof(*allele_lengths));\n const char *alt_allele_state;\n tsk_size_t num_alleles = 1;\n\n if (alleles == NULL || allele_lengths == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n tsk_bug_assert(state != NULL);\n alleles[0] = site->ancestral_state;\n allele_lengths[0] = site->ancestral_state_length;\n\n for (mutation_index = 0; mutation_index < site->mutations_length; mutation_index++) {\n mutation = site->mutations[mutation_index];\n /* Compute the allele index for this derived state value. */\n for (allele = 0; allele < num_alleles; allele++) {\n if (mutation.derived_state_length == allele_lengths[allele]\n && tsk_memcmp(\n mutation.derived_state, alleles[allele], allele_lengths[allele])\n == 0) {\n break;\n }\n }\n if (allele == num_alleles) {\n tsk_bug_assert(allele < max_alleles);\n alleles[allele] = mutation.derived_state;\n allele_lengths[allele] = mutation.derived_state_length;\n num_alleles++;\n }\n\n /* Add the mutation's samples to this allele */\n tsk_bitset_union(\n out_allele_samples, allele + site_offset, state, mutation_index);\n\n /* Get the index for the alternate allele that we must subtract from */\n alt_allele_state = site->ancestral_state;\n alt_allele_length = site->ancestral_state_length;\n if (mutation.parent != TSK_NULL) {\n parent_mut = site->mutations[mutation.parent - site->mutations[0].id];\n alt_allele_state = parent_mut.derived_state;\n alt_allele_length = parent_mut.derived_state_length;\n }\n for (alt_allele = 0; alt_allele < num_alleles; alt_allele++) {\n if (alt_allele_length == allele_lengths[alt_allele]\n && tsk_memcmp(\n alt_allele_state, alleles[alt_allele], allele_lengths[alt_allele])\n == 0) {\n break;\n }\n }\n tsk_bug_assert(allele < num_alleles);\n\n tsk_bitset_subtract(out_allele_samples, alt_allele + site_offset,\n out_allele_samples, allele + site_offset);\n }\n *out_num_alleles = num_alleles;\nout:\n tsk_safe_free(alleles);\n tsk_safe_free(allele_lengths);\n return ret;\n}\n\nstatic int\nnorm_hap_weighted(tsk_size_t result_dim, const double *hap_weights,\n tsk_size_t TSK_UNUSED(n_a), tsk_size_t TSK_UNUSED(n_b), double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *weight_row;\n double n;\n tsk_size_t k;\n\n for (k = 0; k < result_dim; k++) {\n weight_row = GET_2D_ROW(hap_weights, 3, k);\n n = (double) args.sample_set_sizes[k];\n result[k] = weight_row[0] / n;\n }\n return 0;\n}\n\nstatic int\nnorm_hap_weighted_ij(tsk_size_t result_dim, const double *hap_weights,\n tsk_size_t TSK_UNUSED(n_a), tsk_size_t TSK_UNUSED(n_b), double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *weight_row;\n double ni, nj, wAB_i, wAB_j;\n tsk_id_t i, j;\n tsk_size_t k;\n\n for (k = 0; k < result_dim; k++) {\n i = args.set_indexes[2 * k];\n j = args.set_indexes[2 * k + 1];\n ni = (double) args.sample_set_sizes[i];\n nj = (double) args.sample_set_sizes[j];\n weight_row = GET_2D_ROW(hap_weights, 3, i);\n wAB_i = weight_row[0];\n weight_row = GET_2D_ROW(hap_weights, 3, j);\n wAB_j = weight_row[0];\n\n result[k] = (wAB_i + wAB_j) / (ni + nj);\n }\n\n return 0;\n}\n\nstatic int\nnorm_total_weighted(tsk_size_t result_dim, const double *TSK_UNUSED(hap_weights),\n tsk_size_t n_a, tsk_size_t n_b, double *result, void *TSK_UNUSED(params))\n{\n tsk_size_t k;\n double norm = 1 / (double) (n_a * n_b);\n\n for (k = 0; k < result_dim; k++) {\n result[k] = norm;\n }\n return 0;\n}\n\nstatic void\nget_all_samples_bits(tsk_bitset_t *all_samples, tsk_size_t n)\n{\n tsk_size_t i;\n const tsk_bitset_val_t all = ~((tsk_bitset_val_t) 0);\n const tsk_bitset_val_t remainder_samples = n % TSK_BITSET_BITS;\n\n all_samples->data[all_samples->row_len - 1]\n = remainder_samples ? ~(all << remainder_samples) : all;\n for (i = 0; i < all_samples->row_len - 1; i++) {\n all_samples->data[i] = all;\n }\n}\n\n// Stores the intermediate values for computing two-locus statistics.\ntypedef struct {\n double *weights;\n double *norm;\n double *result_tmp;\n tsk_bitset_t AB_samples;\n} two_locus_work_t;\n\nstatic int\ntwo_locus_work_init(tsk_size_t max_alleles, tsk_size_t num_samples,\n tsk_size_t result_dim, tsk_size_t state_dim, two_locus_work_t *out)\n{\n int ret = 0;\n\n out->weights = tsk_malloc(3 * state_dim * sizeof(*out->weights));\n out->norm = tsk_malloc(result_dim * sizeof(*out->norm));\n out->result_tmp\n = tsk_malloc(result_dim * max_alleles * max_alleles * sizeof(*out->result_tmp));\n tsk_memset(&out->AB_samples, 0, sizeof(out->AB_samples));\n if (out->weights == NULL || out->norm == NULL || out->result_tmp == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n ret = tsk_bitset_init(&out->AB_samples, num_samples, 1);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nstatic void\ntwo_locus_work_free(two_locus_work_t *work)\n{\n tsk_safe_free(work->weights);\n tsk_safe_free(work->norm);\n tsk_safe_free(work->result_tmp);\n tsk_bitset_free(&work->AB_samples);\n}\n\nstatic int\ncompute_general_normed_two_site_stat_result(const tsk_bitset_t *state,\n const tsk_size_t *allele_counts, tsk_size_t a_off, tsk_size_t b_off,\n tsk_size_t num_a_alleles, tsk_size_t num_b_alleles, tsk_size_t state_dim,\n tsk_size_t result_dim, general_stat_func_t *f, sample_count_stat_params_t *f_params,\n norm_func_t *norm_f, bool polarised, two_locus_work_t *restrict work, double *result)\n{\n int ret = 0;\n // Sample sets and b sites are rows, a sites are columns\n // b1 b2 b3\n // a1 [s1, s2, s3] [s1, s2, s3] [s1, s2, s3]\n // a2 [s1, s2, s3] [s1, s2, s3] [s1, s2, s3]\n // a3 [s1, s2, s3] [s1, s2, s3] [s1, s2, s3]\n tsk_size_t k, mut_a, mut_b, result_row_len = num_b_alleles * result_dim;\n uint8_t is_polarised = polarised ? 1 : 0;\n double *restrict hap_row, *restrict result_tmp_row;\n double *restrict norm = work->norm;\n double *restrict weights = work->weights;\n double *restrict result_tmp = work->result_tmp;\n tsk_bitset_t AB_samples = work->AB_samples;\n\n for (mut_a = is_polarised; mut_a < num_a_alleles; mut_a++) {\n result_tmp_row = GET_2D_ROW(result_tmp, result_row_len, mut_a);\n for (mut_b = is_polarised; mut_b < num_b_alleles; mut_b++) {\n for (k = 0; k < state_dim; k++) {\n tsk_bitset_intersect(state, a_off + (mut_a * state_dim) + k, state,\n b_off + (mut_b * state_dim) + k, &AB_samples);\n hap_row = GET_2D_ROW(weights, 3, k);\n hap_row[0] = (double) tsk_bitset_count(&AB_samples, 0);\n hap_row[1] = (double) allele_counts[a_off + (mut_a * state_dim) + k]\n - hap_row[0];\n hap_row[2] = (double) allele_counts[b_off + (mut_b * state_dim) + k]\n - hap_row[0];\n }\n ret = f(state_dim, weights, result_dim, result_tmp_row, f_params);\n if (ret != 0) {\n goto out;\n }\n ret = norm_f(result_dim, weights, num_a_alleles - is_polarised,\n num_b_alleles - is_polarised, norm, f_params);\n if (ret != 0) {\n goto out;\n }\n for (k = 0; k < result_dim; k++) {\n result[k] += result_tmp_row[k] * norm[k];\n }\n result_tmp_row += result_dim; // Advance to the next column\n }\n }\nout:\n return ret;\n}\n\nstatic int\ncompute_general_two_site_stat_result(const tsk_bitset_t *state,\n const tsk_size_t *allele_counts, tsk_size_t a_off, tsk_size_t b_off,\n tsk_size_t state_dim, tsk_size_t result_dim, general_stat_func_t *f,\n sample_count_stat_params_t *f_params, two_locus_work_t *restrict work,\n double *result)\n{\n int ret = 0;\n tsk_size_t k;\n tsk_bitset_t AB_samples = work->AB_samples;\n tsk_size_t mut_a = 1, mut_b = 1;\n double *restrict hap_row, *restrict weights = work->weights;\n\n for (k = 0; k < state_dim; k++) {\n tsk_bitset_intersect(state, a_off + (mut_a * state_dim) + k, state,\n b_off + (mut_b * state_dim) + k, &AB_samples);\n hap_row = GET_2D_ROW(weights, 3, k);\n hap_row[0] = (double) tsk_bitset_count(&AB_samples, 0);\n hap_row[1]\n = (double) allele_counts[a_off + (mut_a * state_dim) + k] - hap_row[0];\n hap_row[2]\n = (double) allele_counts[b_off + (mut_b * state_dim) + k] - hap_row[0];\n }\n ret = f(state_dim, weights, result_dim, result, f_params);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nstatic void\nget_site_row_col_indices(tsk_size_t n_rows, const tsk_id_t *row_sites, tsk_size_t n_cols,\n const tsk_id_t *col_sites, tsk_id_t *sites, tsk_size_t *n_sites, tsk_size_t *row_idx,\n tsk_size_t *col_idx)\n{\n tsk_size_t r = 0, c = 0, s = 0;\n\n // Iterate rows and columns until we've exhaused one of the lists\n while ((r < n_rows) && (c < n_cols)) {\n if (row_sites[r] < col_sites[c]) {\n sites[s] = row_sites[r];\n row_idx[r] = s;\n s++;\n r++;\n } else if (col_sites[c] < row_sites[r]) {\n sites[s] = col_sites[c];\n col_idx[c] = s;\n s++;\n c++;\n } else { // row == col\n sites[s] = row_sites[r];\n col_idx[c] = s;\n row_idx[r] = s;\n s++;\n r++;\n c++;\n }\n }\n\n // If there are any items remaining in the other list, drain it\n while (r < n_rows) {\n sites[s] = row_sites[r];\n row_idx[r] = s;\n s++;\n r++;\n }\n while (c < n_cols) {\n sites[s] = col_sites[c];\n col_idx[c] = s;\n s++;\n c++;\n }\n *n_sites = s;\n}\n\nstatic int\nget_mutation_samples(const tsk_treeseq_t *ts, const tsk_id_t *sites, tsk_size_t n_sites,\n tsk_size_t *num_alleles, tsk_bitset_t *allele_samples)\n{\n int ret = 0;\n const tsk_flags_t *restrict flags = ts->tables->nodes.flags;\n const tsk_size_t num_samples = tsk_treeseq_get_num_samples(ts);\n const tsk_size_t *restrict site_muts_len = ts->site_mutations_length;\n tsk_site_t site;\n tsk_tree_t tree;\n tsk_bitset_t all_samples_bits, mut_samples;\n tsk_size_t max_muts_len, site_offset, num_nodes, site_idx, s, m, n;\n tsk_id_t node, *nodes = NULL;\n void *tmp_nodes;\n\n tsk_memset(&mut_samples, 0, sizeof(mut_samples));\n tsk_memset(&all_samples_bits, 0, sizeof(all_samples_bits));\n\n max_muts_len = 0;\n for (s = 0; s < n_sites; s++) {\n max_muts_len = TSK_MAX(site_muts_len[sites[s]], max_muts_len);\n }\n // Allocate a bit array of size max alleles for all sites\n ret = tsk_bitset_init(&mut_samples, num_samples, max_muts_len);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_bitset_init(&all_samples_bits, num_samples, 1);\n if (ret != 0) {\n goto out;\n }\n get_all_samples_bits(&all_samples_bits, num_samples);\n ret = tsk_tree_init(&tree, ts, TSK_NO_SAMPLE_COUNTS);\n if (ret != 0) {\n goto out;\n }\n\n // For each mutation within each site, perform one preorder traversal to gather\n // the samples under each mutation's node.\n site_offset = 0;\n for (site_idx = 0; site_idx < n_sites; site_idx++) {\n tsk_treeseq_get_site(ts, sites[site_idx], &site);\n ret = tsk_tree_seek(&tree, site.position, 0);\n if (ret != 0) {\n goto out;\n }\n tmp_nodes = tsk_realloc(nodes, tsk_tree_get_size_bound(&tree) * sizeof(*nodes));\n if (tmp_nodes == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n nodes = tmp_nodes;\n tsk_bitset_union(allele_samples, site_offset, &all_samples_bits, 0);\n // Zero out results before the start of each iteration\n tsk_memset(mut_samples.data, 0,\n mut_samples.row_len * max_muts_len * sizeof(tsk_bitset_val_t));\n for (m = 0; m < site.mutations_length; m++) {\n node = site.mutations[m].node;\n ret = tsk_tree_preorder_from(&tree, node, nodes, &num_nodes);\n if (ret != 0) {\n goto out;\n }\n for (n = 0; n < num_nodes; n++) {\n node = nodes[n];\n if (flags[node] & TSK_NODE_IS_SAMPLE) {\n tsk_bitset_set_bit(\n &mut_samples, m, (tsk_bitset_val_t) ts->sample_index_map[node]);\n }\n }\n }\n get_allele_samples(\n &site, site_offset, &mut_samples, allele_samples, &(num_alleles[site_idx]));\n site_offset += site.mutations_length + 1;\n }\n// if adding code below, check ret before continuing\nout:\n tsk_safe_free(nodes);\n tsk_tree_free(&tree);\n tsk_bitset_free(&mut_samples);\n tsk_bitset_free(&all_samples_bits);\n return ret == TSK_TREE_OK ? 0 : ret;\n}\n\n// Given the samples under each allele's node and the sample sets, get the samples under\n// each allele's node for each sample set. We pack this data into a bitset\n// (`allele_sample_sets`) that is size m x n, where m is (n_alleles * num_sample_sets)\n// and n is the size of the largest sample set. In addition, we compute the number of\n// samples contained in the intersection of each allele's samples and each sample set in\n// an array (`allele_sample_sets`) of length (n_alleles * num_sample_sets).\nstatic void\nget_mutation_sample_sets(const tsk_bitset_t *allele_samples, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n const tsk_id_t *sample_index_map, tsk_bitset_t *allele_sample_sets,\n tsk_size_t *allele_sample_set_counts)\n{\n tsk_bitset_val_t k, sample;\n tsk_size_t i, j, ss_off;\n\n for (i = 0; i < allele_samples->len; i++) {\n ss_off = 0;\n for (j = 0; j < num_sample_sets; j++) {\n for (k = 0; k < sample_set_sizes[j]; k++) {\n sample = (tsk_bitset_val_t) sample_index_map[sample_sets[k + ss_off]];\n if (tsk_bitset_contains(allele_samples, i, sample)) {\n tsk_bitset_set_bit(allele_sample_sets, j + i * num_sample_sets, k);\n allele_sample_set_counts[j + i * num_sample_sets]++;\n }\n }\n ss_off += sample_set_sizes[j];\n }\n }\n}\n\nstatic int\ntsk_treeseq_two_site_count_stat(const tsk_treeseq_t *self, tsk_size_t state_dim,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t result_dim, general_stat_func_t *f,\n sample_count_stat_params_t *f_params, norm_func_t *norm_f, tsk_size_t n_rows,\n const tsk_id_t *row_sites, tsk_size_t n_cols, const tsk_id_t *col_sites,\n tsk_flags_t options, double *result)\n{\n int ret = 0;\n tsk_bitset_t allele_samples, allele_sample_sets;\n bool polarised = options & TSK_STAT_POLARISED;\n tsk_id_t *sites;\n tsk_size_t i, j, n_sites, *row_idx, *col_idx;\n double *result_row;\n const tsk_size_t num_samples = self->num_samples;\n tsk_size_t *num_alleles = NULL, *site_offsets = NULL, *allele_counts = NULL;\n tsk_size_t result_row_len = n_cols * result_dim;\n tsk_size_t max_ss_size = 0, max_alleles = 0, n_alleles = 0;\n two_locus_work_t work;\n\n tsk_memset(&work, 0, sizeof(work));\n tsk_memset(&allele_samples, 0, sizeof(allele_samples));\n tsk_memset(&allele_sample_sets, 0, sizeof(allele_sample_sets));\n sites = tsk_malloc(self->tables->sites.num_rows * sizeof(*sites));\n row_idx = tsk_malloc(self->tables->sites.num_rows * sizeof(*row_idx));\n col_idx = tsk_malloc(self->tables->sites.num_rows * sizeof(*col_idx));\n if (sites == NULL || row_idx == NULL || col_idx == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n get_site_row_col_indices(\n n_rows, row_sites, n_cols, col_sites, sites, &n_sites, row_idx, col_idx);\n // depends on n_sites\n num_alleles = tsk_malloc(n_sites * sizeof(*num_alleles));\n site_offsets = tsk_malloc(n_sites * sizeof(*site_offsets));\n if (num_alleles == NULL || site_offsets == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n for (i = 0; i < n_sites; i++) {\n site_offsets[i] = n_alleles * num_sample_sets;\n n_alleles += self->site_mutations_length[sites[i]] + 1;\n max_alleles = TSK_MAX(self->site_mutations_length[sites[i]], max_alleles);\n }\n max_alleles++; // add 1 for the ancestral allele\n // depends on n_alleles\n ret = tsk_bitset_init(&allele_samples, num_samples, n_alleles);\n if (ret != 0) {\n goto out;\n }\n for (i = 0; i < num_sample_sets; i++) {\n max_ss_size = TSK_MAX(sample_set_sizes[i], max_ss_size);\n }\n // depend on n_alleles and max_ss_size\n ret = tsk_bitset_init(&allele_sample_sets, max_ss_size, n_alleles * num_sample_sets);\n if (ret != 0) {\n goto out;\n }\n allele_counts = tsk_calloc(n_alleles * num_sample_sets, sizeof(*allele_counts));\n if (allele_counts == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n // depends on max_ss_size and max_alleles\n ret = two_locus_work_init(max_alleles, max_ss_size, result_dim, state_dim, &work);\n if (ret != 0) {\n goto out;\n }\n // we track the number of alleles to account for backmutations\n ret = get_mutation_samples(self, sites, n_sites, num_alleles, &allele_samples);\n if (ret != 0) {\n goto out;\n }\n get_mutation_sample_sets(&allele_samples, num_sample_sets, sample_set_sizes,\n sample_sets, self->sample_index_map, &allele_sample_sets, allele_counts);\n // For each row/column pair, fill in the sample set in the result matrix.\n for (i = 0; i < n_rows; i++) {\n result_row = GET_2D_ROW(result, result_row_len, i);\n for (j = 0; j < n_cols; j++) {\n if (num_alleles[row_idx[i]] == 2 && num_alleles[col_idx[j]] == 2) {\n // both sites are biallelic\n ret = compute_general_two_site_stat_result(&allele_sample_sets,\n allele_counts, site_offsets[row_idx[i]], site_offsets[col_idx[j]],\n state_dim, result_dim, f, f_params, &work,\n &(result_row[j * result_dim]));\n } else {\n // at least one site is multiallelic\n ret = compute_general_normed_two_site_stat_result(&allele_sample_sets,\n allele_counts, site_offsets[row_idx[i]], site_offsets[col_idx[j]],\n num_alleles[row_idx[i]], num_alleles[col_idx[j]], state_dim,\n result_dim, f, f_params, norm_f, polarised, &work,\n &(result_row[j * result_dim]));\n }\n if (ret != 0) {\n goto out;\n }\n }\n }\n\nout:\n tsk_safe_free(sites);\n tsk_safe_free(row_idx);\n tsk_safe_free(col_idx);\n tsk_safe_free(num_alleles);\n tsk_safe_free(site_offsets);\n tsk_safe_free(allele_counts);\n two_locus_work_free(&work);\n tsk_bitset_free(&allele_samples);\n tsk_bitset_free(&allele_sample_sets);\n return ret;\n}\n\nstatic int\nsample_sets_to_bitset(const tsk_treeseq_t *self, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_sample_sets,\n tsk_bitset_t *sample_sets_bits)\n{\n int ret;\n tsk_size_t j, k, l;\n tsk_id_t u, sample_index;\n\n ret = tsk_bitset_init(sample_sets_bits, self->num_samples, num_sample_sets);\n if (ret != 0) {\n return ret;\n }\n j = 0;\n for (k = 0; k < num_sample_sets; k++) {\n for (l = 0; l < sample_set_sizes[k]; l++) {\n u = sample_sets[j];\n sample_index = self->sample_index_map[u];\n if (tsk_bitset_contains(\n sample_sets_bits, k, (tsk_bitset_val_t) sample_index)) {\n ret = tsk_trace_error(TSK_ERR_DUPLICATE_SAMPLE);\n goto out;\n }\n tsk_bitset_set_bit(sample_sets_bits, k, (tsk_bitset_val_t) sample_index);\n j++;\n }\n }\n\nout:\n return ret;\n}\n\nstatic int\ncheck_sites(const tsk_id_t *sites, tsk_size_t num_sites, tsk_size_t num_site_rows)\n{\n int ret = 0;\n tsk_size_t i;\n\n if (num_sites == 0) {\n return ret; // No need to verify sites if there aren't any\n }\n\n for (i = 0; i < num_sites - 1; i++) {\n if (sites[i] < 0 || sites[i] >= (tsk_id_t) num_site_rows) {\n ret = tsk_trace_error(TSK_ERR_SITE_OUT_OF_BOUNDS);\n goto out;\n }\n if (sites[i] > sites[i + 1]) {\n ret = tsk_trace_error(TSK_ERR_STAT_UNSORTED_SITES);\n goto out;\n }\n if (sites[i] == sites[i + 1]) {\n ret = tsk_trace_error(TSK_ERR_STAT_DUPLICATE_SITES);\n goto out;\n }\n }\n // check the last value\n if (sites[i] < 0 || sites[i] >= (tsk_id_t) num_site_rows) {\n ret = tsk_trace_error(TSK_ERR_SITE_OUT_OF_BOUNDS);\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int\ncheck_positions(\n const double *positions, tsk_size_t num_positions, double sequence_length)\n{\n int ret = 0;\n tsk_size_t i;\n\n if (num_positions == 0) {\n return ret; // No need to verify positions if there aren't any\n }\n\n for (i = 0; i < num_positions - 1; i++) {\n if (positions[i] < 0 || positions[i] >= sequence_length) {\n ret = tsk_trace_error(TSK_ERR_POSITION_OUT_OF_BOUNDS);\n goto out;\n }\n if (positions[i] > positions[i + 1]) {\n ret = tsk_trace_error(TSK_ERR_STAT_UNSORTED_POSITIONS);\n goto out;\n }\n if (positions[i] == positions[i + 1]) {\n ret = tsk_trace_error(TSK_ERR_STAT_DUPLICATE_POSITIONS);\n goto out;\n }\n }\n // check bounds of last value\n if (positions[i] < 0 || positions[i] >= sequence_length) {\n ret = tsk_trace_error(TSK_ERR_POSITION_OUT_OF_BOUNDS);\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int\npositions_to_tree_indexes(const tsk_treeseq_t *ts, const double *positions,\n tsk_size_t num_positions, tsk_id_t **tree_indexes)\n{\n int ret = 0;\n tsk_id_t tree_index = 0;\n tsk_size_t i, num_trees = ts->num_trees;\n\n // This is tricky. If there are 0 positions, we calloc a size of 1\n // we must calloc, because memset will have no effect when called with size 0\n *tree_indexes = tsk_calloc(num_positions, sizeof(*tree_indexes));\n if (tree_indexes == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(*tree_indexes, TSK_NULL, num_positions * sizeof(**tree_indexes));\n for (i = 0; i < num_positions; i++) {\n while (ts->breakpoints[tree_index + 1] <= positions[i]) {\n tree_index++;\n }\n (*tree_indexes)[i] = tree_index;\n }\n tsk_bug_assert(tree_index <= (tsk_id_t) (num_trees - 1));\n\nout:\n return ret;\n}\n\nstatic int\nget_index_counts(\n const tsk_id_t *indexes, tsk_size_t num_indexes, tsk_size_t **out_counts)\n{\n int ret = 0;\n tsk_id_t index = indexes[0];\n tsk_size_t count, i;\n tsk_size_t *counts = tsk_calloc(\n (tsk_size_t) (indexes[num_indexes ? num_indexes - 1 : 0] - indexes[0] + 1),\n sizeof(*counts));\n if (counts == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n count = 1;\n for (i = 1; i < num_indexes; i++) {\n if (indexes[i] == indexes[i - 1]) {\n count++;\n } else {\n counts[index - indexes[0]] = count;\n count = 1;\n index = indexes[i];\n }\n }\n counts[index - indexes[0]] = count;\n *out_counts = counts;\nout:\n return ret;\n}\n\ntypedef struct {\n tsk_tree_t tree;\n tsk_bitset_t *node_samples;\n tsk_id_t *parent;\n tsk_id_t *edges_out;\n tsk_id_t *edges_in;\n double *branch_len;\n tsk_size_t n_edges_out;\n tsk_size_t n_edges_in;\n} iter_state;\n\nstatic int\niter_state_init(iter_state *self, const tsk_treeseq_t *ts, tsk_size_t state_dim)\n{\n int ret = 0;\n const tsk_size_t num_nodes = ts->tables->nodes.num_rows;\n\n ret = tsk_tree_init(&self->tree, ts, TSK_NO_SAMPLE_COUNTS);\n if (ret != 0) {\n goto out;\n }\n self->node_samples = tsk_calloc(1, sizeof(*self->node_samples));\n if (self->node_samples == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n ret = tsk_bitset_init(self->node_samples, ts->num_samples, state_dim * num_nodes);\n if (ret != 0) {\n goto out;\n }\n self->parent = tsk_malloc(num_nodes * sizeof(*self->parent));\n self->edges_out = tsk_malloc(num_nodes * sizeof(*self->edges_out));\n self->edges_in = tsk_malloc(num_nodes * sizeof(*self->edges_in));\n self->branch_len = tsk_calloc(num_nodes, sizeof(*self->branch_len));\n if (self->parent == NULL || self->edges_out == NULL || self->edges_in == NULL\n || self->branch_len == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int\nget_node_samples(const tsk_treeseq_t *ts, tsk_size_t state_dim,\n const tsk_bitset_t *sample_sets, tsk_bitset_t *node_samples)\n{\n int ret = 0;\n tsk_size_t n, k;\n tsk_size_t num_nodes = ts->tables->nodes.num_rows;\n tsk_bitset_val_t sample;\n const tsk_id_t *restrict sample_index_map = ts->sample_index_map;\n const tsk_flags_t *restrict flags = ts->tables->nodes.flags;\n\n ret = tsk_bitset_init(node_samples, ts->num_samples, num_nodes * state_dim);\n if (ret != 0) {\n goto out;\n }\n for (k = 0; k < state_dim; k++) {\n for (n = 0; n < num_nodes; n++) {\n if (flags[n] & TSK_NODE_IS_SAMPLE) {\n sample = (tsk_bitset_val_t) sample_index_map[n];\n if (tsk_bitset_contains(sample_sets, k, sample)) {\n tsk_bitset_set_bit(node_samples, (state_dim * n) + k, sample);\n }\n }\n }\n }\nout:\n return ret;\n}\n\nstatic void\niter_state_clear(iter_state *self, tsk_size_t state_dim, tsk_size_t num_nodes,\n const tsk_bitset_t *node_samples)\n{\n self->n_edges_out = 0;\n self->n_edges_in = 0;\n tsk_tree_clear(&self->tree);\n tsk_memset(self->parent, TSK_NULL, num_nodes * sizeof(*self->parent));\n tsk_memset(self->edges_out, TSK_NULL, num_nodes * sizeof(*self->edges_out));\n tsk_memset(self->edges_in, TSK_NULL, num_nodes * sizeof(*self->edges_in));\n tsk_memset(self->branch_len, 0, num_nodes * sizeof(*self->branch_len));\n tsk_memcpy(self->node_samples->data, node_samples->data,\n node_samples->row_len * state_dim * num_nodes * sizeof(*node_samples->data));\n}\n\nstatic void\niter_state_free(iter_state *self)\n{\n tsk_tree_free(&self->tree);\n tsk_bitset_free(self->node_samples);\n tsk_safe_free(self->node_samples);\n tsk_safe_free(self->parent);\n tsk_safe_free(self->edges_out);\n tsk_safe_free(self->edges_in);\n tsk_safe_free(self->branch_len);\n}\n\nstatic int\nadvance_collect_edges(iter_state *s, tsk_id_t index)\n{\n int ret = 0;\n tsk_id_t j, e;\n tsk_size_t i;\n double left, right;\n tsk_tree_position_t pos;\n tsk_tree_t *tree = &s->tree;\n const double *restrict edge_left = tree->tree_sequence->tables->edges.left;\n const double *restrict edge_right = tree->tree_sequence->tables->edges.right;\n\n // Either we're seeking forward one step from some nonzero position in the tree, or\n // from the beginning of the tree sequence.\n if (tree->index != TSK_NULL || index == 0) {\n ret = tsk_tree_next(tree);\n if (ret < 0) {\n goto out;\n }\n pos = tree->tree_pos;\n i = 0;\n for (j = pos.out.start; j != pos.out.stop; j++) {\n s->edges_out[i] = pos.out.order[j];\n i++;\n }\n s->n_edges_out = i;\n i = 0;\n for (j = pos.in.start; j != pos.in.stop; j++) {\n s->edges_in[i] = pos.in.order[j];\n i++;\n }\n s->n_edges_in = i;\n } else {\n // Seek from an arbitrary nonzero position from an uninitialized tree.\n tsk_bug_assert(tree->index == -1);\n ret = tsk_tree_seek_index(tree, index, 0);\n if (ret < 0) {\n goto out;\n }\n pos = tree->tree_pos;\n i = 0;\n if (pos.direction == TSK_DIR_FORWARD) {\n left = pos.interval.left;\n for (j = pos.in.start; j != pos.in.stop; j++) {\n e = pos.in.order[j];\n if (edge_left[e] <= left && left < edge_right[e]) {\n s->edges_in[i] = pos.in.order[j];\n i++;\n }\n }\n } else {\n right = pos.interval.right;\n for (j = pos.in.start; j != pos.in.stop; j--) {\n e = pos.in.order[j];\n if (edge_right[e] >= right && right > edge_left[e]) {\n s->edges_in[i] = pos.in.order[j];\n i++;\n }\n }\n }\n s->n_edges_out = 0;\n s->n_edges_in = i;\n }\n ret = 0;\nout:\n return ret;\n}\n\nstatic int\ncompute_two_tree_branch_state_update(const tsk_treeseq_t *ts, tsk_id_t c,\n const iter_state *A_state, const iter_state *B_state, tsk_size_t state_dim,\n tsk_size_t result_dim, int sign, general_stat_func_t *f,\n sample_count_stat_params_t *f_params, two_locus_work_t *restrict work,\n double *result)\n{\n int ret = 0;\n double a_len, b_len;\n double *restrict B_branch_len = B_state->branch_len;\n double *weights_row;\n tsk_size_t n, k, a_row, b_row;\n const double *restrict A_branch_len = A_state->branch_len;\n const tsk_bitset_t *restrict A_state_samples = A_state->node_samples;\n const tsk_bitset_t *restrict B_state_samples = B_state->node_samples;\n tsk_size_t num_nodes = ts->tables->nodes.num_rows;\n double *weights = work->weights;\n double *result_tmp = work->result_tmp;\n tsk_bitset_t AB_samples = work->AB_samples;\n\n b_len = B_branch_len[c] * sign;\n if (b_len == 0) {\n return ret;\n }\n for (n = 0; n < num_nodes; n++) {\n a_len = A_branch_len[n];\n if (a_len == 0) {\n continue;\n }\n for (k = 0; k < state_dim; k++) {\n a_row = (state_dim * n) + k;\n b_row = (state_dim * (tsk_size_t) c) + k;\n weights_row = GET_2D_ROW(weights, 3, k);\n tsk_bitset_intersect(\n A_state_samples, a_row, B_state_samples, b_row, &AB_samples);\n weights_row[0] = (double) tsk_bitset_count(&AB_samples, 0);\n weights_row[1]\n = (double) tsk_bitset_count(A_state_samples, a_row) - weights_row[0];\n weights_row[2]\n = (double) tsk_bitset_count(B_state_samples, b_row) - weights_row[0];\n }\n ret = f(state_dim, weights, result_dim, result_tmp, f_params);\n if (ret != 0) {\n goto out;\n }\n for (k = 0; k < result_dim; k++) {\n result[k] += result_tmp[k] * a_len * b_len;\n }\n }\nout:\n return ret;\n}\n\nstatic int\ncompute_two_tree_branch_stat(const tsk_treeseq_t *ts, const iter_state *l_state,\n iter_state *r_state, general_stat_func_t *f, sample_count_stat_params_t *f_params,\n tsk_size_t result_dim, tsk_size_t state_dim, double *result)\n{\n int ret = 0;\n tsk_id_t e, c, ec, p, *updated_nodes = NULL;\n tsk_size_t j, k, n_updates;\n const double *restrict time = ts->tables->nodes.time;\n const tsk_id_t *restrict edges_child = ts->tables->edges.child;\n const tsk_id_t *restrict edges_parent = ts->tables->edges.parent;\n const tsk_size_t num_nodes = ts->tables->nodes.num_rows;\n tsk_bitset_t updates, *r_samples = r_state->node_samples;\n two_locus_work_t work;\n\n tsk_memset(&work, 0, sizeof(work));\n tsk_memset(&updates, 0, sizeof(updates));\n // only two alleles are possible for branch stats\n ret = two_locus_work_init(2, ts->num_samples, result_dim, state_dim, &work);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_bitset_init(&updates, num_nodes, 1);\n if (ret != 0) {\n goto out;\n }\n updated_nodes = tsk_calloc(num_nodes, sizeof(*updated_nodes));\n if (updated_nodes == NULL) {\n ret = TSK_ERR_NO_MEMORY;\n goto out;\n }\n // Identify modified nodes both added and removed\n for (j = 0; j < r_state->n_edges_out + r_state->n_edges_in; j++) {\n e = j < r_state->n_edges_out ? r_state->edges_out[j]\n : r_state->edges_in[j - r_state->n_edges_out];\n p = edges_parent[e];\n c = edges_child[e];\n // Identify affected nodes above child\n while (p != TSK_NULL) {\n tsk_bitset_set_bit(&updates, 0, (tsk_bitset_val_t) c);\n c = p;\n p = r_state->parent[p];\n }\n }\n // Subtract the whole contribution from the child node\n tsk_bitset_get_items(&updates, 0, updated_nodes, &n_updates);\n while (n_updates != 0) {\n n_updates--;\n c = updated_nodes[n_updates];\n compute_two_tree_branch_state_update(ts, c, l_state, r_state, state_dim,\n result_dim, -1, f, f_params, &work, result);\n }\n // Remove samples under nodes from removed edges to parent nodes\n for (j = 0; j < r_state->n_edges_out; j++) {\n e = r_state->edges_out[j];\n p = edges_parent[e];\n ec = edges_child[e]; // edge child\n while (p != TSK_NULL) {\n for (k = 0; k < state_dim; k++) {\n tsk_bitset_subtract(r_samples, (state_dim * (tsk_size_t) p) + k,\n r_samples, (state_dim * (tsk_size_t) ec) + k);\n }\n p = r_state->parent[p];\n }\n r_state->branch_len[ec] = 0;\n r_state->parent[ec] = TSK_NULL;\n }\n // Add samples under nodes from added edges\n for (j = 0; j < r_state->n_edges_in; j++) {\n e = r_state->edges_in[j];\n p = edges_parent[e];\n ec = c = edges_child[e];\n r_state->branch_len[c] = time[p] - time[c];\n r_state->parent[c] = p;\n while (p != TSK_NULL) {\n tsk_bitset_set_bit(&updates, 0, (tsk_bitset_val_t) c);\n for (k = 0; k < state_dim; k++) {\n tsk_bitset_union(r_samples, (state_dim * (tsk_size_t) p) + k, r_samples,\n (state_dim * (tsk_size_t) ec) + k);\n }\n c = p;\n p = r_state->parent[p];\n }\n }\n // Update all affected child nodes (fully subtracted, deferred from addition)\n n_updates = 0;\n tsk_bitset_get_items(&updates, 0, updated_nodes, &n_updates);\n while (n_updates != 0) {\n n_updates--;\n c = updated_nodes[n_updates];\n compute_two_tree_branch_state_update(ts, c, l_state, r_state, state_dim,\n result_dim, +1, f, f_params, &work, result);\n }\nout:\n tsk_safe_free(updated_nodes);\n two_locus_work_free(&work);\n tsk_bitset_free(&updates);\n return ret;\n}\n\nstatic int\ntsk_treeseq_two_branch_count_stat(const tsk_treeseq_t *self, tsk_size_t state_dim,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t result_dim, general_stat_func_t *f,\n sample_count_stat_params_t *f_params, norm_func_t *TSK_UNUSED(norm_f),\n tsk_size_t n_rows, const double *row_positions, tsk_size_t n_cols,\n const double *col_positions, tsk_flags_t TSK_UNUSED(options), double *result)\n{\n int ret = 0;\n int r, c;\n tsk_id_t *row_indexes = NULL, *col_indexes = NULL;\n tsk_size_t i, j, k, row, col, *row_repeats = NULL, *col_repeats = NULL;\n tsk_bitset_t node_samples, sample_sets_bits;\n iter_state l_state, r_state;\n double *result_tmp = NULL, *result_row;\n const tsk_size_t num_nodes = self->tables->nodes.num_rows;\n\n tsk_memset(&sample_sets_bits, 0, sizeof(sample_sets_bits));\n tsk_memset(&node_samples, 0, sizeof(node_samples));\n tsk_memset(&l_state, 0, sizeof(l_state));\n tsk_memset(&r_state, 0, sizeof(r_state));\n result_tmp = tsk_malloc(result_dim * sizeof(*result_tmp));\n if (result_tmp == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n ret = iter_state_init(&l_state, self, state_dim);\n if (ret != 0) {\n goto out;\n }\n ret = iter_state_init(&r_state, self, state_dim);\n if (ret != 0) {\n goto out;\n }\n ret = sample_sets_to_bitset(\n self, sample_set_sizes, sample_sets, num_sample_sets, &sample_sets_bits);\n if (ret != 0) {\n goto out;\n }\n ret = positions_to_tree_indexes(self, row_positions, n_rows, &row_indexes);\n if (ret != 0) {\n goto out;\n }\n ret = positions_to_tree_indexes(self, col_positions, n_cols, &col_indexes);\n if (ret != 0) {\n goto out;\n }\n ret = get_index_counts(row_indexes, n_rows, &row_repeats);\n if (ret != 0) {\n goto out;\n }\n ret = get_index_counts(col_indexes, n_cols, &col_repeats);\n if (ret != 0) {\n goto out;\n }\n ret = get_node_samples(self, state_dim, &sample_sets_bits, &node_samples);\n if (ret != 0) {\n goto out;\n }\n iter_state_clear(&l_state, state_dim, num_nodes, &node_samples);\n row = 0;\n for (r = 0; r < (row_indexes[n_rows ? n_rows - 1U : 0] - row_indexes[0] + 1); r++) {\n tsk_memset(result_tmp, 0, result_dim * sizeof(*result_tmp));\n iter_state_clear(&r_state, state_dim, num_nodes, &node_samples);\n ret = advance_collect_edges(&l_state, (tsk_id_t) r + row_indexes[0]);\n if (ret != 0) {\n goto out;\n }\n result_row = GET_2D_ROW(result, result_dim * n_cols, row);\n ret = compute_two_tree_branch_stat(\n self, &r_state, &l_state, f, f_params, result_dim, state_dim, result_tmp);\n if (ret != 0) {\n goto out;\n }\n col = 0;\n for (c = 0; c < (col_indexes[n_cols ? n_cols - 1 : 0] - col_indexes[0] + 1);\n c++) {\n ret = advance_collect_edges(&r_state, (tsk_id_t) c + col_indexes[0]);\n if (ret != 0) {\n goto out;\n }\n ret = compute_two_tree_branch_stat(self, &l_state, &r_state, f, f_params,\n result_dim, state_dim, result_tmp);\n if (ret != 0) {\n goto out;\n }\n for (i = 0; i < row_repeats[r]; i++) {\n for (j = 0; j < col_repeats[c]; j++) {\n result_row = GET_2D_ROW(result, result_dim * n_cols, row + i);\n for (k = 0; k < result_dim; k++) {\n result_row[col + (j * result_dim) + k] = result_tmp[k];\n }\n }\n }\n col += (col_repeats[c] * result_dim);\n }\n row += row_repeats[r];\n }\nout:\n tsk_safe_free(result_tmp);\n tsk_safe_free(row_indexes);\n tsk_safe_free(col_indexes);\n tsk_safe_free(row_repeats);\n tsk_safe_free(col_repeats);\n iter_state_free(&l_state);\n iter_state_free(&r_state);\n tsk_bitset_free(&node_samples);\n tsk_bitset_free(&sample_sets_bits);\n return ret;\n}\n\nstatic int\ncheck_sample_set_dups(tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, const tsk_id_t *restrict sample_index_map,\n tsk_size_t num_samples)\n{\n int ret;\n tsk_size_t j, k, l;\n tsk_id_t u, sample_index;\n tsk_bitset_t tmp;\n\n tsk_memset(&tmp, 0, sizeof(tmp));\n ret = tsk_bitset_init(&tmp, num_samples, 1);\n if (ret != 0) {\n goto out;\n }\n j = 0;\n for (k = 0; k < num_sample_sets; k++) {\n tsk_memset(tmp.data, 0, sizeof(*tmp.data) * tmp.row_len);\n for (l = 0; l < sample_set_sizes[k]; l++) {\n u = sample_sets[j];\n sample_index = sample_index_map[u];\n if (tsk_bitset_contains(&tmp, 0, (tsk_bitset_val_t) sample_index)) {\n ret = tsk_trace_error(TSK_ERR_DUPLICATE_SAMPLE);\n goto out;\n }\n tsk_bitset_set_bit(&tmp, 0, (tsk_bitset_val_t) sample_index);\n j++;\n }\n }\nout:\n tsk_bitset_free(&tmp);\n return ret;\n}\n\nint\ntsk_treeseq_two_locus_count_stat(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t result_dim, const tsk_id_t *set_indexes, general_stat_func_t *f,\n norm_func_t *norm_f, tsk_size_t out_rows, const tsk_id_t *row_sites,\n const double *row_positions, tsk_size_t out_cols, const tsk_id_t *col_sites,\n const double *col_positions, tsk_flags_t options, double *result)\n{\n // TODO: generalize this function if we ever decide to do weighted two_locus stats.\n // We only implement count stats and therefore we don't handle weights.\n int ret = 0;\n bool stat_site = !!(options & TSK_STAT_SITE);\n bool stat_branch = !!(options & TSK_STAT_BRANCH);\n tsk_size_t state_dim = num_sample_sets;\n sample_count_stat_params_t f_params = { .sample_sets = sample_sets,\n .num_sample_sets = num_sample_sets,\n .sample_set_sizes = sample_set_sizes,\n .set_indexes = set_indexes };\n\n // We do not support two-locus node stats\n if (!!(options & TSK_STAT_NODE)) {\n ret = tsk_trace_error(TSK_ERR_UNSUPPORTED_STAT_MODE);\n goto out;\n }\n // If no mode is specified, we default to site mode\n if (!(stat_site || stat_branch)) {\n stat_site = true;\n }\n // It's an error to specify more than one mode\n if (stat_site + stat_branch > 1) {\n ret = tsk_trace_error(TSK_ERR_MULTIPLE_STAT_MODES);\n goto out;\n }\n ret = tsk_treeseq_check_sample_sets(\n self, num_sample_sets, sample_set_sizes, sample_sets);\n if (ret != 0) {\n goto out;\n }\n if (result_dim < 1) {\n ret = tsk_trace_error(TSK_ERR_BAD_RESULT_DIMS);\n goto out;\n }\n if (stat_site) {\n ret = check_sites(row_sites, out_rows, self->tables->sites.num_rows);\n if (ret != 0) {\n goto out;\n }\n ret = check_sites(col_sites, out_cols, self->tables->sites.num_rows);\n if (ret != 0) {\n goto out;\n }\n ret = check_sample_set_dups(num_sample_sets, sample_set_sizes, sample_sets,\n self->sample_index_map, self->num_samples);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_two_site_count_stat(self, state_dim, num_sample_sets,\n sample_set_sizes, sample_sets, result_dim, f, &f_params, norm_f, out_rows,\n row_sites, out_cols, col_sites, options, result);\n } else if (stat_branch) {\n ret = check_positions(\n row_positions, out_rows, tsk_treeseq_get_sequence_length(self));\n if (ret != 0) {\n goto out;\n }\n ret = check_positions(\n col_positions, out_cols, tsk_treeseq_get_sequence_length(self));\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_two_branch_count_stat(self, state_dim, num_sample_sets,\n sample_set_sizes, sample_sets, result_dim, f, &f_params, norm_f, out_rows,\n row_positions, out_cols, col_positions, options, result);\n }\nout:\n return ret;\n}\n\n/***********************************\n * Allele frequency spectrum\n ***********************************/\n\nstatic inline void\nfold(tsk_size_t *restrict coordinate, const tsk_size_t *restrict dims,\n tsk_size_t num_dims)\n{\n tsk_size_t k;\n double n = 0;\n int s = 0;\n\n for (k = 0; k < num_dims; k++) {\n tsk_bug_assert(coordinate[k] < dims[k]);\n n += (double) dims[k] - 1;\n s += (int) coordinate[k];\n }\n n /= 2;\n k = num_dims;\n while (s == n && k > 0) {\n k--;\n n -= ((double) (dims[k] - 1)) / 2;\n s -= (int) coordinate[k];\n }\n if (s > n) {\n for (k = 0; k < num_dims; k++) {\n s = (int) (dims[k] - 1 - coordinate[k]);\n tsk_bug_assert(s >= 0);\n coordinate[k] = (tsk_size_t) s;\n }\n }\n}\n\nstatic int\ntsk_treeseq_update_site_afs(const tsk_treeseq_t *self, const tsk_site_t *site,\n const double *total_counts, const double *counts, tsk_size_t num_sample_sets,\n tsk_size_t window_index, tsk_size_t *result_dims, tsk_flags_t options,\n double *result)\n{\n int ret = 0;\n tsk_size_t afs_size;\n tsk_size_t k, allele, num_alleles, all_samples;\n double increment, *afs, *allele_counts, *allele_count;\n tsk_size_t *coordinate = tsk_malloc(num_sample_sets * sizeof(*coordinate));\n bool polarised = !!(options & TSK_STAT_POLARISED);\n const tsk_size_t K = num_sample_sets + 1;\n\n if (coordinate == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n ret = get_allele_weights(\n site, counts, K, total_counts, &num_alleles, &allele_counts);\n if (ret != 0) {\n goto out;\n }\n\n afs_size = result_dims[num_sample_sets];\n afs = result + afs_size * window_index;\n\n increment = polarised ? 1 : 0.5;\n /* Sum over the allele weights. Skip the ancestral state if polarised. */\n for (allele = polarised ? 1 : 0; allele < num_alleles; allele++) {\n allele_count = GET_2D_ROW(allele_counts, K, allele);\n all_samples = (tsk_size_t) allele_count[num_sample_sets];\n if (all_samples > 0 && all_samples < self->num_samples) {\n for (k = 0; k < num_sample_sets; k++) {\n coordinate[k] = (tsk_size_t) allele_count[k];\n }\n if (!polarised) {\n fold(coordinate, result_dims, num_sample_sets);\n }\n increment_nd_array_value(\n afs, num_sample_sets, result_dims, coordinate, increment);\n }\n }\nout:\n tsk_safe_free(coordinate);\n tsk_safe_free(allele_counts);\n return ret;\n}\n\nstatic int\ntsk_treeseq_site_allele_frequency_spectrum(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes, double *counts,\n tsk_size_t num_windows, const double *windows, tsk_size_t *result_dims,\n tsk_flags_t options, double *result)\n{\n int ret = 0;\n tsk_id_t u, v;\n tsk_size_t tree_site, tree_index, window_index;\n tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const tsk_id_t num_edges = (tsk_id_t) self->tables->edges.num_rows;\n const tsk_id_t *restrict I = self->tables->indexes.edge_insertion_order;\n const tsk_id_t *restrict O = self->tables->indexes.edge_removal_order;\n const double *restrict edge_left = self->tables->edges.left;\n const double *restrict edge_right = self->tables->edges.right;\n const tsk_id_t *restrict edge_parent = self->tables->edges.parent;\n const tsk_id_t *restrict edge_child = self->tables->edges.child;\n const double sequence_length = self->tables->sequence_length;\n tsk_id_t *restrict parent = tsk_malloc(num_nodes * sizeof(*parent));\n tsk_site_t *site;\n tsk_id_t tj, tk, h;\n tsk_size_t j;\n const tsk_size_t K = num_sample_sets + 1;\n double t_left, t_right;\n double *total_counts = tsk_malloc((1 + num_sample_sets) * sizeof(*total_counts));\n\n if (parent == NULL || total_counts == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(parent, 0xff, num_nodes * sizeof(*parent));\n\n for (j = 0; j < num_sample_sets; j++) {\n total_counts[j] = (double) sample_set_sizes[j];\n }\n total_counts[num_sample_sets] = (double) self->num_samples;\n\n /* Iterate over the trees */\n tj = 0;\n tk = 0;\n t_left = 0;\n tree_index = 0;\n window_index = 0;\n while (tj < num_edges || t_left < sequence_length) {\n while (tk < num_edges && edge_right[O[tk]] == t_left) {\n h = O[tk];\n tk++;\n u = edge_child[h];\n v = edge_parent[h];\n while (v != TSK_NULL) {\n update_state(counts, K, v, u, -1);\n v = parent[v];\n }\n parent[u] = TSK_NULL;\n }\n\n while (tj < num_edges && edge_left[I[tj]] == t_left) {\n h = I[tj];\n tj++;\n u = edge_child[h];\n v = edge_parent[h];\n parent[u] = v;\n while (v != TSK_NULL) {\n update_state(counts, K, v, u, +1);\n v = parent[v];\n }\n }\n t_right = sequence_length;\n if (tj < num_edges) {\n t_right = TSK_MIN(t_right, edge_left[I[tj]]);\n }\n if (tk < num_edges) {\n t_right = TSK_MIN(t_right, edge_right[O[tk]]);\n }\n\n /* Update the sites */\n for (tree_site = 0; tree_site < self->tree_sites_length[tree_index];\n tree_site++) {\n site = self->tree_sites[tree_index] + tree_site;\n while (windows[window_index + 1] <= site->position) {\n window_index++;\n tsk_bug_assert(window_index < num_windows);\n }\n ret = tsk_treeseq_update_site_afs(self, site, total_counts, counts,\n num_sample_sets, window_index, result_dims, options, result);\n if (ret != 0) {\n goto out;\n }\n tsk_bug_assert(windows[window_index] <= site->position);\n tsk_bug_assert(site->position < windows[window_index + 1]);\n }\n tree_index++;\n t_left = t_right;\n }\nout:\n /* Can't use msp_safe_free here because of restrict */\n if (parent != NULL) {\n free(parent);\n }\n tsk_safe_free(total_counts);\n return ret;\n}\n\nstatic void\ntsk_treeseq_update_branch_afs(const tsk_treeseq_t *self, tsk_id_t u, double right,\n double *restrict last_update, const double *restrict time, tsk_id_t *restrict parent,\n tsk_size_t *restrict coordinate, const double *counts, tsk_size_t num_sample_sets,\n tsk_size_t num_time_windows, const double *time_windows, tsk_size_t window_index,\n const tsk_size_t *result_dims, tsk_flags_t options, double *result)\n{\n tsk_size_t afs_size;\n tsk_size_t k;\n tsk_size_t time_window_index;\n double *afs;\n bool polarised = !!(options & TSK_STAT_POLARISED);\n const double *count_row = GET_2D_ROW(counts, num_sample_sets + 1, u);\n double x = 0;\n double t_u, t_v;\n double tw_branch_length = 0;\n const tsk_size_t all_samples = (tsk_size_t) count_row[num_sample_sets];\n if (parent[u] != TSK_NULL) {\n t_u = time[u];\n t_v = time[parent[u]];\n if (0 < all_samples && all_samples < self->num_samples) {\n time_window_index = 0;\n afs_size = result_dims[num_sample_sets];\n while (time_window_index < num_time_windows\n && time_windows[time_window_index] < t_v) {\n afs = result\n + afs_size * (window_index * num_time_windows + time_window_index);\n for (k = 0; k < num_sample_sets; k++) {\n coordinate[k] = (tsk_size_t) count_row[k];\n }\n if (!polarised) {\n fold(coordinate, result_dims, num_sample_sets);\n }\n tw_branch_length\n = TSK_MAX(0.0, TSK_MIN(time_windows[time_window_index + 1], t_v)\n - TSK_MAX(time_windows[time_window_index], t_u));\n x = (right - last_update[u]) * tw_branch_length;\n increment_nd_array_value(\n afs, num_sample_sets, result_dims, coordinate, x);\n time_window_index++;\n }\n }\n }\n last_update[u] = right;\n}\n\nstatic int\ntsk_treeseq_branch_allele_frequency_spectrum(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, double *counts, tsk_size_t num_windows,\n const double *windows, tsk_size_t num_time_windows, const double *time_windows,\n const tsk_size_t *result_dims, tsk_flags_t options, double *result)\n{\n int ret = 0;\n tsk_id_t u, v;\n tsk_size_t window_index;\n tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const tsk_id_t num_edges = (tsk_id_t) self->tables->edges.num_rows;\n const tsk_id_t *restrict I = self->tables->indexes.edge_insertion_order;\n const tsk_id_t *restrict O = self->tables->indexes.edge_removal_order;\n const double *restrict edge_left = self->tables->edges.left;\n const double *restrict edge_right = self->tables->edges.right;\n const tsk_id_t *restrict edge_parent = self->tables->edges.parent;\n const tsk_id_t *restrict edge_child = self->tables->edges.child;\n const double *restrict node_time = self->tables->nodes.time;\n const double sequence_length = self->tables->sequence_length;\n tsk_id_t *restrict parent = tsk_malloc(num_nodes * sizeof(*parent));\n double *restrict last_update = tsk_calloc(num_nodes, sizeof(*last_update));\n double *restrict branch_length = tsk_calloc(num_nodes, sizeof(*branch_length));\n tsk_size_t *restrict coordinate = tsk_malloc(num_sample_sets * sizeof(*coordinate));\n tsk_id_t tj, tk, h;\n double t_left, t_right, w_right;\n const tsk_size_t K = num_sample_sets + 1;\n\n if (self->time_uncalibrated && !(options & TSK_STAT_ALLOW_TIME_UNCALIBRATED)) {\n ret = tsk_trace_error(TSK_ERR_TIME_UNCALIBRATED);\n goto out;\n }\n\n if (parent == NULL || last_update == NULL || coordinate == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(parent, 0xff, num_nodes * sizeof(*parent));\n\n /* Iterate over the trees */\n tj = 0;\n tk = 0;\n t_left = 0;\n window_index = 0;\n while (tj < num_edges || t_left < sequence_length) {\n tsk_bug_assert(window_index < num_windows);\n while (tk < num_edges && edge_right[O[tk]] == t_left) {\n h = O[tk];\n tk++;\n u = edge_child[h];\n v = edge_parent[h];\n tsk_treeseq_update_branch_afs(self, u, t_left, last_update, node_time,\n parent, coordinate, counts, num_sample_sets, num_time_windows,\n time_windows, window_index, result_dims, options, result);\n while (v != TSK_NULL) {\n tsk_treeseq_update_branch_afs(self, v, t_left, last_update, node_time,\n parent, coordinate, counts, num_sample_sets, num_time_windows,\n time_windows, window_index, result_dims, options, result);\n update_state(counts, K, v, u, -1);\n v = parent[v];\n }\n parent[u] = TSK_NULL;\n branch_length[u] = 0;\n }\n\n while (tj < num_edges && edge_left[I[tj]] == t_left) {\n h = I[tj];\n tj++;\n u = edge_child[h];\n v = edge_parent[h];\n parent[u] = v;\n branch_length[u] = node_time[v] - node_time[u];\n while (v != TSK_NULL) {\n tsk_treeseq_update_branch_afs(self, v, t_left, last_update, node_time,\n parent, coordinate, counts, num_sample_sets, num_time_windows,\n time_windows, window_index, result_dims, options, result);\n update_state(counts, K, v, u, +1);\n v = parent[v];\n }\n }\n\n t_right = sequence_length;\n if (tj < num_edges) {\n t_right = TSK_MIN(t_right, edge_left[I[tj]]);\n }\n if (tk < num_edges) {\n t_right = TSK_MIN(t_right, edge_right[O[tk]]);\n }\n\n while (window_index < num_windows && windows[window_index + 1] <= t_right) {\n w_right = windows[window_index + 1];\n /* Flush the contributions of all nodes to the current window */\n for (u = 0; u < (tsk_id_t) num_nodes; u++) {\n tsk_bug_assert(last_update[u] < w_right);\n tsk_treeseq_update_branch_afs(self, u, w_right, last_update, node_time,\n parent, coordinate, counts, num_sample_sets, num_time_windows,\n time_windows, window_index, result_dims, options, result);\n }\n window_index++;\n }\n\n t_left = t_right;\n }\nout:\n /* Can't use msp_safe_free here because of restrict */\n if (parent != NULL) {\n free(parent);\n }\n if (last_update != NULL) {\n free(last_update);\n }\n if (branch_length != NULL) {\n free(branch_length);\n }\n if (coordinate != NULL) {\n free(coordinate);\n }\n return ret;\n}\n\nint\ntsk_treeseq_allele_frequency_spectrum(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_windows, const double *windows,\n tsk_size_t num_time_windows, const double *time_windows, tsk_flags_t options,\n double *result)\n{\n int ret = 0;\n bool stat_site = !!(options & TSK_STAT_SITE);\n bool stat_branch = !!(options & TSK_STAT_BRANCH);\n bool stat_node = !!(options & TSK_STAT_NODE);\n const double default_windows[] = { 0, self->tables->sequence_length };\n const double default_time_windows[] = { 0, INFINITY };\n const tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const tsk_size_t K = num_sample_sets + 1;\n tsk_size_t j, k, l, afs_size;\n tsk_id_t u;\n tsk_size_t *result_dims = NULL;\n /* These counts should really be ints, but we use doubles so that we can\n * reuse code from the general_stats code paths. */\n double *counts = NULL;\n double *count_row;\n if (stat_node) {\n ret = tsk_trace_error(TSK_ERR_UNSUPPORTED_STAT_MODE);\n goto out;\n }\n /* If no mode is specified, we default to site mode */\n if (!(stat_site || stat_branch)) {\n stat_site = true;\n }\n /* It's an error to specify more than one mode */\n if (stat_site + stat_branch > 1) {\n ret = tsk_trace_error(TSK_ERR_MULTIPLE_STAT_MODES);\n goto out;\n }\n if (windows == NULL) {\n num_windows = 1;\n windows = default_windows;\n } else {\n ret = tsk_treeseq_check_windows(\n self, num_windows, windows, TSK_REQUIRE_FULL_SPAN);\n if (ret != 0) {\n goto out;\n }\n }\n if (time_windows == NULL) {\n num_time_windows = 1;\n time_windows = default_time_windows;\n } else {\n ret = tsk_treeseq_check_time_windows(num_time_windows, time_windows);\n if (ret != 0) {\n goto out;\n }\n // Site mode does not support time windows\n if (stat_site && !(time_windows[0] == 0.0 && isinf((float) time_windows[1]))) {\n ret = TSK_ERR_UNSUPPORTED_STAT_MODE;\n goto out;\n }\n }\n ret = tsk_treeseq_check_sample_sets(\n self, num_sample_sets, sample_set_sizes, sample_sets);\n if (ret != 0) {\n goto out;\n }\n\n /* the last element of result_dims stores the total size of the dimensions */\n result_dims = tsk_malloc((num_sample_sets + 1) * sizeof(*result_dims));\n counts = tsk_calloc(num_nodes * K, sizeof(*counts));\n if (counts == NULL || result_dims == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n afs_size = 1;\n j = 0;\n for (k = 0; k < num_sample_sets; k++) {\n result_dims[k] = 1 + sample_set_sizes[k];\n afs_size *= result_dims[k];\n for (l = 0; l < sample_set_sizes[k]; l++) {\n u = sample_sets[j];\n count_row = GET_2D_ROW(counts, K, u);\n if (count_row[k] != 0) {\n ret = tsk_trace_error(TSK_ERR_DUPLICATE_SAMPLE);\n goto out;\n }\n count_row[k] = 1;\n j++;\n }\n }\n for (j = 0; j < self->num_samples; j++) {\n u = self->samples[j];\n count_row = GET_2D_ROW(counts, K, u);\n count_row[num_sample_sets] = 1;\n }\n result_dims[num_sample_sets] = (tsk_size_t) afs_size;\n tsk_memset(result, 0, num_windows * num_time_windows * afs_size * sizeof(*result));\n\n if (stat_site) {\n ret = tsk_treeseq_site_allele_frequency_spectrum(self, num_sample_sets,\n sample_set_sizes, counts, num_windows, windows, result_dims, options,\n result);\n } else {\n ret = tsk_treeseq_branch_allele_frequency_spectrum(self, num_sample_sets, counts,\n num_windows, windows, num_time_windows, time_windows, result_dims, options,\n result);\n }\n\n if (options & TSK_STAT_SPAN_NORMALISE) {\n span_normalise(num_windows, windows, afs_size * num_time_windows, result);\n }\nout:\n tsk_safe_free(counts);\n tsk_safe_free(result_dims);\n return ret;\n}\n\n/***********************************\n * One way stats\n ***********************************/\n\nstatic int\ndiversity_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t TSK_UNUSED(result_dim), double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *x = state;\n double n;\n tsk_size_t j;\n\n for (j = 0; j < state_dim; j++) {\n n = (double) args.sample_set_sizes[j];\n result[j] = x[j] * (n - x[j]) / (n * (n - 1));\n }\n return 0;\n}\n\nint\ntsk_treeseq_diversity(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_windows, const double *windows, tsk_flags_t options, double *result)\n{\n return tsk_treeseq_sample_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_sample_sets, NULL, diversity_summary_func, num_windows, windows,\n options, result);\n}\n\nstatic int\ntrait_covariance_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t TSK_UNUSED(result_dim), double *result, void *params)\n{\n weight_stat_params_t args = *(weight_stat_params_t *) params;\n const double n = (double) args.num_samples;\n const double *x = state;\n tsk_size_t j;\n\n for (j = 0; j < state_dim; j++) {\n result[j] = (x[j] * x[j]) / (2 * (n - 1) * (n - 1));\n }\n return 0;\n}\n\nint\ntsk_treeseq_trait_covariance(const tsk_treeseq_t *self, tsk_size_t num_weights,\n const double *weights, tsk_size_t num_windows, const double *windows,\n tsk_flags_t options, double *result)\n{\n tsk_size_t num_samples = self->num_samples;\n tsk_size_t j, k;\n int ret;\n const double *row;\n double *new_row;\n double *means = tsk_calloc(num_weights, sizeof(double));\n double *new_weights = tsk_malloc((num_weights + 1) * num_samples * sizeof(double));\n weight_stat_params_t args = { num_samples = self->num_samples };\n\n if (new_weights == NULL || means == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n if (num_weights == 0) {\n ret = tsk_trace_error(TSK_ERR_INSUFFICIENT_WEIGHTS);\n goto out;\n }\n\n // center weights\n for (j = 0; j < num_samples; j++) {\n row = GET_2D_ROW(weights, num_weights, j);\n for (k = 0; k < num_weights; k++) {\n means[k] += row[k];\n }\n }\n for (k = 0; k < num_weights; k++) {\n means[k] /= (double) num_samples;\n }\n for (j = 0; j < num_samples; j++) {\n row = GET_2D_ROW(weights, num_weights, j);\n new_row = GET_2D_ROW(new_weights, num_weights, j);\n for (k = 0; k < num_weights; k++) {\n new_row[k] = row[k] - means[k];\n }\n }\n\n ret = tsk_treeseq_general_stat(self, num_weights, new_weights, num_weights,\n trait_covariance_summary_func, &args, num_windows, windows, options, result);\n\nout:\n tsk_safe_free(means);\n tsk_safe_free(new_weights);\n return ret;\n}\n\nstatic int\ntrait_correlation_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t TSK_UNUSED(result_dim), double *result, void *params)\n{\n weight_stat_params_t args = *(weight_stat_params_t *) params;\n const double n = (double) args.num_samples;\n const double *x = state;\n double p;\n tsk_size_t j;\n\n p = x[state_dim - 1];\n for (j = 0; j < state_dim - 1; j++) {\n if ((p > 0.0) && (p < 1.0)) {\n result[j] = (x[j] * x[j]) / (2 * (p * (1 - p)) * n * (n - 1));\n } else {\n result[j] = 0.0;\n }\n }\n return 0;\n}\n\nint\ntsk_treeseq_trait_correlation(const tsk_treeseq_t *self, tsk_size_t num_weights,\n const double *weights, tsk_size_t num_windows, const double *windows,\n tsk_flags_t options, double *result)\n{\n tsk_size_t num_samples = self->num_samples;\n tsk_size_t j, k;\n int ret;\n double *means = tsk_calloc(num_weights, sizeof(double));\n double *meansqs = tsk_calloc(num_weights, sizeof(double));\n double *sds = tsk_calloc(num_weights, sizeof(double));\n const double *row;\n double *new_row;\n double *new_weights = tsk_malloc((num_weights + 1) * num_samples * sizeof(double));\n weight_stat_params_t args = { num_samples = self->num_samples };\n\n if (new_weights == NULL || means == NULL || meansqs == NULL || sds == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n if (num_weights < 1) {\n ret = tsk_trace_error(TSK_ERR_INSUFFICIENT_WEIGHTS);\n goto out;\n }\n\n // center and scale weights\n for (j = 0; j < num_samples; j++) {\n row = GET_2D_ROW(weights, num_weights, j);\n for (k = 0; k < num_weights; k++) {\n means[k] += row[k];\n meansqs[k] += row[k] * row[k];\n }\n }\n for (k = 0; k < num_weights; k++) {\n means[k] /= (double) num_samples;\n meansqs[k] -= means[k] * means[k] * (double) num_samples;\n meansqs[k] /= (double) (num_samples - 1);\n sds[k] = sqrt(meansqs[k]);\n }\n for (j = 0; j < num_samples; j++) {\n row = GET_2D_ROW(weights, num_weights, j);\n new_row = GET_2D_ROW(new_weights, num_weights + 1, j);\n for (k = 0; k < num_weights; k++) {\n new_row[k] = (row[k] - means[k]) / sds[k];\n }\n // set final row to 1/n to compute frequency\n new_row[num_weights] = 1.0 / (double) num_samples;\n }\n\n ret = tsk_treeseq_general_stat(self, num_weights + 1, new_weights, num_weights,\n trait_correlation_summary_func, &args, num_windows, windows, options, result);\n\nout:\n tsk_safe_free(means);\n tsk_safe_free(meansqs);\n tsk_safe_free(sds);\n tsk_safe_free(new_weights);\n return ret;\n}\n\nstatic int\ntrait_linear_model_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t result_dim, double *result, void *params)\n{\n covariates_stat_params_t args = *(covariates_stat_params_t *) params;\n const double num_samples = (double) args.num_samples;\n const tsk_size_t k = args.num_covariates;\n const double *V = args.V;\n ;\n const double *x = state;\n const double *v;\n double m, a, denom, z;\n tsk_size_t i, j;\n // x[0], ..., x[result_dim - 1] contains the traits, W\n // x[result_dim], ..., x[state_dim - 2] contains the covariates, Z\n // x[state_dim - 1] has the number of samples below the node\n\n m = x[state_dim - 1];\n for (i = 0; i < result_dim; i++) {\n if ((m > 0.0) && (m < num_samples)) {\n v = GET_2D_ROW(V, k, i);\n a = x[i];\n denom = m;\n for (j = 0; j < k; j++) {\n z = x[result_dim + j];\n a -= z * v[j];\n denom -= z * z;\n }\n // denom is the length of projection of the trait onto the subspace\n // spanned by the covariates, so if it is zero then the system is\n // singular and the solution is nonunique. This numerical tolerance\n // could be smaller without hitting floating-point error, but being\n // a tiny bit conservative about when the trait is almost in the\n // span of the covariates is probably good.\n if (denom < 1e-8) {\n result[i] = 0.0;\n } else {\n result[i] = (a * a) / (2 * denom * denom);\n }\n } else {\n result[i] = 0.0;\n }\n }\n return 0;\n}\n\nint\ntsk_treeseq_trait_linear_model(const tsk_treeseq_t *self, tsk_size_t num_weights,\n const double *weights, tsk_size_t num_covariates, const double *covariates,\n tsk_size_t num_windows, const double *windows, tsk_flags_t options, double *result)\n{\n tsk_size_t num_samples = self->num_samples;\n tsk_size_t i, j, k;\n int ret;\n const double *w, *z;\n double *v, *new_row;\n double *V = tsk_calloc(num_covariates * num_weights, sizeof(double));\n double *new_weights\n = tsk_malloc((num_weights + num_covariates + 1) * num_samples * sizeof(double));\n\n covariates_stat_params_t args\n = { .num_samples = self->num_samples, .num_covariates = num_covariates, .V = V };\n\n // We assume that the covariates have been *already standardised*,\n // so that (a) 1 is in the span of the columns, and\n // (b) their crossproduct is the identity.\n // We could do this instead here with gsl linalg.\n\n if (new_weights == NULL || V == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n if (num_weights < 1) {\n ret = tsk_trace_error(TSK_ERR_INSUFFICIENT_WEIGHTS);\n goto out;\n }\n\n // V = weights^T (matrix mult) covariates\n for (k = 0; k < num_samples; k++) {\n w = GET_2D_ROW(weights, num_weights, k);\n z = GET_2D_ROW(covariates, num_covariates, k);\n for (i = 0; i < num_weights; i++) {\n v = GET_2D_ROW(V, num_covariates, i);\n for (j = 0; j < num_covariates; j++) {\n v[j] += w[i] * z[j];\n }\n }\n }\n\n for (k = 0; k < num_samples; k++) {\n w = GET_2D_ROW(weights, num_weights, k);\n z = GET_2D_ROW(covariates, num_covariates, k);\n new_row = GET_2D_ROW(new_weights, num_covariates + num_weights + 1, k);\n for (i = 0; i < num_weights; i++) {\n new_row[i] = w[i];\n }\n for (i = 0; i < num_covariates; i++) {\n new_row[i + num_weights] = z[i];\n }\n // set final row to 1 to count alleles\n new_row[num_weights + num_covariates] = 1.0;\n }\n\n ret = tsk_treeseq_general_stat(self, num_weights + num_covariates + 1, new_weights,\n num_weights, trait_linear_model_summary_func, &args, num_windows, windows,\n options, result);\n\nout:\n tsk_safe_free(V);\n tsk_safe_free(new_weights);\n return ret;\n}\n\nstatic int\nsegregating_sites_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t TSK_UNUSED(result_dim), double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *x = state;\n double n;\n tsk_size_t j;\n\n // this works because sum_{i=1}^k (1-p_i) = k-1\n for (j = 0; j < state_dim; j++) {\n n = (double) args.sample_set_sizes[j];\n result[j] = (x[j] > 0) * (1 - x[j] / n);\n }\n return 0;\n}\n\nint\ntsk_treeseq_segregating_sites(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_windows, const double *windows, tsk_flags_t options, double *result)\n{\n return tsk_treeseq_sample_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_sample_sets, NULL, segregating_sites_summary_func, num_windows,\n windows, options, result);\n}\n\nstatic int\nY1_summary_func(tsk_size_t TSK_UNUSED(state_dim), const double *state,\n tsk_size_t result_dim, double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *x = state;\n double ni, denom, numer;\n tsk_size_t i;\n\n for (i = 0; i < result_dim; i++) {\n ni = (double) args.sample_set_sizes[i];\n denom = ni * (ni - 1) * (ni - 2);\n numer = x[i] * (ni - x[i]) * (ni - x[i] - 1);\n result[i] = numer / denom;\n }\n return 0;\n}\n\nint\ntsk_treeseq_Y1(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_windows, const double *windows, tsk_flags_t options, double *result)\n{\n return tsk_treeseq_sample_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_sample_sets, NULL, Y1_summary_func, num_windows, windows,\n options, result);\n}\n\nstatic int\nD_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t TSK_UNUSED(result_dim), double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n double n;\n const double *state_row;\n tsk_size_t j;\n\n for (j = 0; j < state_dim; j++) {\n n = (double) args.sample_set_sizes[j];\n state_row = GET_2D_ROW(state, 3, j);\n double p_AB = state_row[0] / n;\n double p_Ab = state_row[1] / n;\n double p_aB = state_row[2] / n;\n\n double p_A = p_AB + p_Ab;\n double p_B = p_AB + p_aB;\n result[j] = p_AB - (p_A * p_B);\n }\n\n return 0;\n}\n\nint\ntsk_treeseq_D(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result)\n{\n options |= TSK_STAT_POLARISED; // TODO: allow user to pick?\n return tsk_treeseq_two_locus_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_sample_sets, NULL, D_summary_func, norm_total_weighted,\n num_rows, row_sites, row_positions, num_cols, col_sites, col_positions, options,\n result);\n}\n\nstatic int\nD2_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t TSK_UNUSED(result_dim), double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n double n;\n const double *state_row;\n tsk_size_t j;\n\n for (j = 0; j < state_dim; j++) {\n n = (double) args.sample_set_sizes[j];\n state_row = GET_2D_ROW(state, 3, j);\n double p_AB = state_row[0] / n;\n double p_Ab = state_row[1] / n;\n double p_aB = state_row[2] / n;\n\n double p_A = p_AB + p_Ab;\n double p_B = p_AB + p_aB;\n result[j] = p_AB - (p_A * p_B);\n result[j] *= result[j];\n }\n\n return 0;\n}\n\nint\ntsk_treeseq_D2(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result)\n{\n return tsk_treeseq_two_locus_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_sample_sets, NULL, D2_summary_func, norm_total_weighted,\n num_rows, row_sites, row_positions, num_cols, col_sites, col_positions, options,\n result);\n}\n\nstatic int\nr2_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t TSK_UNUSED(result_dim), double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n double n;\n const double *state_row;\n tsk_size_t j;\n\n for (j = 0; j < state_dim; j++) {\n n = (double) args.sample_set_sizes[j];\n state_row = GET_2D_ROW(state, 3, j);\n double p_AB = state_row[0] / n;\n double p_Ab = state_row[1] / n;\n double p_aB = state_row[2] / n;\n\n double p_A = p_AB + p_Ab;\n double p_B = p_AB + p_aB;\n\n double D = p_AB - (p_A * p_B);\n double denom = p_A * p_B * (1 - p_A) * (1 - p_B);\n\n result[j] = (D * D) / denom;\n }\n return 0;\n}\n\nint\ntsk_treeseq_r2(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result)\n{\n return tsk_treeseq_two_locus_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_sample_sets, NULL, r2_summary_func, norm_hap_weighted, num_rows,\n row_sites, row_positions, num_cols, col_sites, col_positions, options, result);\n}\n\nstatic int\nD_prime_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t TSK_UNUSED(result_dim), double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n double n;\n const double *state_row;\n tsk_size_t j;\n\n for (j = 0; j < state_dim; j++) {\n n = (double) args.sample_set_sizes[j];\n state_row = GET_2D_ROW(state, 3, j);\n double p_AB = state_row[0] / n;\n double p_Ab = state_row[1] / n;\n double p_aB = state_row[2] / n;\n\n double p_A = p_AB + p_Ab;\n double p_B = p_AB + p_aB;\n\n double D = p_AB - (p_A * p_B);\n\n if (D >= 0) {\n result[j] = D / TSK_MIN(p_A * (1 - p_B), (1 - p_A) * p_B);\n } else if (D < 0) {\n result[j] = D / TSK_MIN(p_A * p_B, (1 - p_A) * (1 - p_B));\n }\n }\n return 0;\n}\n\nint\ntsk_treeseq_D_prime(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result)\n{\n options |= TSK_STAT_POLARISED; // TODO: allow user to pick?\n return tsk_treeseq_two_locus_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_sample_sets, NULL, D_prime_summary_func, norm_total_weighted,\n num_rows, row_sites, row_positions, num_cols, col_sites, col_positions, options,\n result);\n}\n\nstatic int\nr_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t TSK_UNUSED(result_dim), double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n double n;\n const double *state_row;\n tsk_size_t j;\n\n for (j = 0; j < state_dim; j++) {\n n = (double) args.sample_set_sizes[j];\n state_row = GET_2D_ROW(state, 3, j);\n double p_AB = state_row[0] / n;\n double p_Ab = state_row[1] / n;\n double p_aB = state_row[2] / n;\n\n double p_A = p_AB + p_Ab;\n double p_B = p_AB + p_aB;\n\n double D = p_AB - (p_A * p_B);\n double denom = p_A * p_B * (1 - p_A) * (1 - p_B);\n\n result[j] = D / sqrt(denom);\n }\n return 0;\n}\n\nint\ntsk_treeseq_r(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result)\n{\n options |= TSK_STAT_POLARISED; // TODO: allow user to pick?\n return tsk_treeseq_two_locus_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_sample_sets, NULL, r_summary_func, norm_total_weighted,\n num_rows, row_sites, row_positions, num_cols, col_sites, col_positions, options,\n result);\n}\n\nstatic int\nDz_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t TSK_UNUSED(result_dim), double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n double n;\n const double *state_row;\n tsk_size_t j;\n\n for (j = 0; j < state_dim; j++) {\n n = (double) args.sample_set_sizes[j];\n state_row = GET_2D_ROW(state, 3, j);\n double p_AB = state_row[0] / n;\n double p_Ab = state_row[1] / n;\n double p_aB = state_row[2] / n;\n\n double p_A = p_AB + p_Ab;\n double p_B = p_AB + p_aB;\n\n double D = p_AB - (p_A * p_B);\n\n result[j] = D * (1 - 2 * p_A) * (1 - 2 * p_B);\n }\n return 0;\n}\n\nint\ntsk_treeseq_Dz(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result)\n{\n return tsk_treeseq_two_locus_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_sample_sets, NULL, Dz_summary_func, norm_total_weighted,\n num_rows, row_sites, row_positions, num_cols, col_sites, col_positions, options,\n result);\n}\n\nstatic int\npi2_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t TSK_UNUSED(result_dim), double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n double n;\n const double *state_row;\n tsk_size_t j;\n\n for (j = 0; j < state_dim; j++) {\n n = (double) args.sample_set_sizes[j];\n state_row = GET_2D_ROW(state, 3, j);\n double p_AB = state_row[0] / n;\n double p_Ab = state_row[1] / n;\n double p_aB = state_row[2] / n;\n\n double p_A = p_AB + p_Ab;\n double p_B = p_AB + p_aB;\n result[j] = p_A * (1 - p_A) * p_B * (1 - p_B);\n }\n return 0;\n}\n\nint\ntsk_treeseq_pi2(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result)\n{\n return tsk_treeseq_two_locus_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_sample_sets, NULL, pi2_summary_func, norm_total_weighted,\n num_rows, row_sites, row_positions, num_cols, col_sites, col_positions, options,\n result);\n}\n\nstatic int\nD2_unbiased_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t TSK_UNUSED(result_dim), double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n double n;\n const double *state_row;\n tsk_size_t j;\n\n for (j = 0; j < state_dim; j++) {\n n = (double) args.sample_set_sizes[j];\n state_row = GET_2D_ROW(state, 3, j);\n double w_AB = state_row[0];\n double w_Ab = state_row[1];\n double w_aB = state_row[2];\n double w_ab = n - (w_AB + w_Ab + w_aB);\n result[j] = (1 / (n * (n - 1) * (n - 2) * (n - 3)))\n * ((w_aB * w_aB * (w_Ab - 1) * w_Ab)\n + ((w_ab - 1) * w_ab * (w_AB - 1) * w_AB)\n - (w_aB * w_Ab * (w_Ab + (2 * w_ab * w_AB) - 1)));\n }\n return 0;\n}\n\nint\ntsk_treeseq_D2_unbiased(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result)\n{\n return tsk_treeseq_two_locus_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_sample_sets, NULL, D2_unbiased_summary_func,\n norm_total_weighted, num_rows, row_sites, row_positions, num_cols, col_sites,\n col_positions, options, result);\n}\n\nstatic int\nDz_unbiased_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t TSK_UNUSED(result_dim), double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n double n;\n const double *state_row;\n tsk_size_t j;\n\n for (j = 0; j < state_dim; j++) {\n n = (double) args.sample_set_sizes[j];\n state_row = GET_2D_ROW(state, 3, j);\n double w_AB = state_row[0];\n double w_Ab = state_row[1];\n double w_aB = state_row[2];\n double w_ab = n - (w_AB + w_Ab + w_aB);\n result[j] = (1 / (n * (n - 1) * (n - 2) * (n - 3)))\n * ((((w_AB * w_ab) - (w_Ab * w_aB)) * (w_aB + w_ab - w_AB - w_Ab)\n * (w_Ab + w_ab - w_AB - w_aB))\n - ((w_AB * w_ab) * (w_AB + w_ab - w_Ab - w_aB - 2))\n - ((w_Ab * w_aB) * (w_Ab + w_aB - w_AB - w_ab - 2)));\n }\n return 0;\n}\n\nint\ntsk_treeseq_Dz_unbiased(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result)\n{\n return tsk_treeseq_two_locus_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_sample_sets, NULL, Dz_unbiased_summary_func,\n norm_total_weighted, num_rows, row_sites, row_positions, num_cols, col_sites,\n col_positions, options, result);\n}\n\nstatic int\npi2_unbiased_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t TSK_UNUSED(result_dim), double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n double n;\n const double *state_row;\n tsk_size_t j;\n\n for (j = 0; j < state_dim; j++) {\n n = (double) args.sample_set_sizes[j];\n state_row = GET_2D_ROW(state, 3, j);\n double w_AB = state_row[0];\n double w_Ab = state_row[1];\n double w_aB = state_row[2];\n double w_ab = n - (w_AB + w_Ab + w_aB);\n result[j] = (1 / (n * (n - 1) * (n - 2) * (n - 3)))\n * (((w_AB + w_Ab) * (w_aB + w_ab) * (w_AB + w_aB) * (w_Ab + w_ab))\n - ((w_AB * w_ab) * (w_AB + w_ab + (3 * w_Ab) + (3 * w_aB) - 1))\n - ((w_Ab * w_aB) * (w_Ab + w_aB + (3 * w_AB) + (3 * w_ab) - 1)));\n }\n return 0;\n}\n\nint\ntsk_treeseq_pi2_unbiased(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result)\n{\n return tsk_treeseq_two_locus_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_sample_sets, NULL, pi2_unbiased_summary_func,\n norm_total_weighted, num_rows, row_sites, row_positions, num_cols, col_sites,\n col_positions, options, result);\n}\n\n/***********************************\n * Two way stats\n ***********************************/\n\nstatic int\ncheck_sample_stat_inputs(tsk_size_t num_sample_sets, tsk_size_t tuple_size,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples)\n{\n int ret = 0;\n\n if (num_sample_sets < 1) {\n ret = tsk_trace_error(TSK_ERR_INSUFFICIENT_SAMPLE_SETS);\n goto out;\n }\n if (num_index_tuples < 1) {\n ret = tsk_trace_error(TSK_ERR_INSUFFICIENT_INDEX_TUPLES);\n goto out;\n }\n ret = check_set_indexes(\n num_sample_sets, tuple_size * num_index_tuples, index_tuples);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int\ndivergence_summary_func(tsk_size_t TSK_UNUSED(state_dim), const double *state,\n tsk_size_t result_dim, double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *x = state;\n double ni, nj, denom;\n tsk_id_t i, j;\n tsk_size_t k;\n\n for (k = 0; k < result_dim; k++) {\n i = args.set_indexes[2 * k];\n j = args.set_indexes[2 * k + 1];\n ni = (double) args.sample_set_sizes[i];\n nj = (double) args.sample_set_sizes[j];\n denom = ni * (nj - (i == j));\n result[k] = x[i] * (nj - x[j]) / denom;\n }\n return 0;\n}\n\nint\ntsk_treeseq_divergence(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_windows,\n const double *windows, tsk_flags_t options, double *result)\n{\n int ret = 0;\n ret = check_sample_stat_inputs(num_sample_sets, 2, num_index_tuples, index_tuples);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_sample_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_index_tuples, index_tuples, divergence_summary_func,\n num_windows, windows, options, result);\nout:\n return ret;\n}\n\nstatic int\ngenetic_relatedness_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t result_dim, double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *x = state;\n tsk_id_t i, j;\n tsk_size_t k;\n double sumx = 0;\n double meanx, ni, nj;\n\n for (k = 0; k < state_dim; k++) {\n sumx += x[k] / (double) args.sample_set_sizes[k];\n }\n\n meanx = sumx / (double) state_dim;\n for (k = 0; k < result_dim; k++) {\n i = args.set_indexes[2 * k];\n j = args.set_indexes[2 * k + 1];\n ni = (double) args.sample_set_sizes[i];\n nj = (double) args.sample_set_sizes[j];\n result[k] = (x[i] / ni - meanx) * (x[j] / nj - meanx);\n }\n return 0;\n}\n\nstatic int\ngenetic_relatedness_noncentred_summary_func(tsk_size_t TSK_UNUSED(state_dim),\n const double *state, tsk_size_t result_dim, double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *x = state;\n tsk_id_t i, j;\n tsk_size_t k;\n double ni, nj;\n\n for (k = 0; k < result_dim; k++) {\n i = args.set_indexes[2 * k];\n j = args.set_indexes[2 * k + 1];\n ni = (double) args.sample_set_sizes[i];\n nj = (double) args.sample_set_sizes[j];\n result[k] = x[i] * x[j] / (ni * nj);\n }\n return 0;\n}\n\nint\ntsk_treeseq_genetic_relatedness(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_windows,\n const double *windows, tsk_flags_t options, double *result)\n{\n int ret = 0;\n ret = check_sample_stat_inputs(num_sample_sets, 2, num_index_tuples, index_tuples);\n if (ret != 0) {\n goto out;\n }\n if (!(options & TSK_STAT_NONCENTRED)) {\n ret = tsk_treeseq_sample_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_index_tuples, index_tuples,\n genetic_relatedness_summary_func, num_windows, windows, options, result);\n } else {\n ret = tsk_treeseq_sample_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_index_tuples, index_tuples,\n genetic_relatedness_noncentred_summary_func, num_windows, windows, options,\n result);\n }\nout:\n return ret;\n}\n\nstatic int\ngenetic_relatedness_weighted_summary_func(tsk_size_t state_dim, const double *state,\n tsk_size_t result_dim, double *result, void *params)\n{\n indexed_weight_stat_params_t args = *(indexed_weight_stat_params_t *) params;\n const double *x = state;\n tsk_id_t i, j;\n tsk_size_t k;\n double pn, ni, nj;\n\n pn = state[state_dim - 1];\n for (k = 0; k < result_dim; k++) {\n i = args.index_tuples[2 * k];\n j = args.index_tuples[2 * k + 1];\n ni = args.total_weights[i];\n nj = args.total_weights[j];\n result[k] = (x[i] - ni * pn) * (x[j] - nj * pn);\n }\n return 0;\n}\n\nstatic int\ngenetic_relatedness_weighted_noncentred_summary_func(tsk_size_t TSK_UNUSED(state_dim),\n const double *state, tsk_size_t result_dim, double *result, void *params)\n{\n indexed_weight_stat_params_t args = *(indexed_weight_stat_params_t *) params;\n const double *x = state;\n tsk_id_t i, j;\n tsk_size_t k;\n\n for (k = 0; k < result_dim; k++) {\n i = args.index_tuples[2 * k];\n j = args.index_tuples[2 * k + 1];\n result[k] = x[i] * x[j];\n }\n return 0;\n}\n\nint\ntsk_treeseq_genetic_relatedness_weighted(const tsk_treeseq_t *self,\n tsk_size_t num_weights, const double *weights, tsk_size_t num_index_tuples,\n const tsk_id_t *index_tuples, tsk_size_t num_windows, const double *windows,\n double *result, tsk_flags_t options)\n{\n int ret = 0;\n tsk_size_t num_samples = self->num_samples;\n size_t j, k;\n indexed_weight_stat_params_t args;\n const double *row;\n double *new_row;\n double *total_weights = tsk_calloc((num_weights + 1), sizeof(*total_weights));\n double *new_weights\n = tsk_malloc((num_weights + 1) * num_samples * sizeof(*new_weights));\n\n if (total_weights == NULL || new_weights == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n if (num_weights == 0) {\n ret = tsk_trace_error(TSK_ERR_INSUFFICIENT_WEIGHTS);\n goto out;\n }\n\n // Add a column of ones to W\n for (j = 0; j < num_samples; j++) {\n row = GET_2D_ROW(weights, num_weights, j);\n new_row = GET_2D_ROW(new_weights, num_weights + 1, j);\n for (k = 0; k < num_weights; k++) {\n new_row[k] = row[k];\n total_weights[k] += row[k];\n }\n new_row[num_weights] = 1.0 / (double) num_samples;\n }\n total_weights[num_weights] = 1.0;\n\n args.total_weights = total_weights;\n args.index_tuples = index_tuples;\n if (!(options & TSK_STAT_NONCENTRED)) {\n ret = tsk_treeseq_general_stat(self, num_weights + 1, new_weights,\n num_index_tuples, genetic_relatedness_weighted_summary_func, &args,\n num_windows, windows, options, result);\n if (ret != 0) {\n goto out;\n }\n } else {\n ret = tsk_treeseq_general_stat(self, num_weights + 1, new_weights,\n num_index_tuples, genetic_relatedness_weighted_noncentred_summary_func,\n &args, num_windows, windows, options, result);\n if (ret != 0) {\n goto out;\n }\n }\n\nout:\n tsk_safe_free(total_weights);\n tsk_safe_free(new_weights);\n return ret;\n}\n\nstatic int\nY2_summary_func(tsk_size_t TSK_UNUSED(state_dim), const double *state,\n tsk_size_t result_dim, double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *x = state;\n double ni, nj, denom;\n tsk_id_t i, j;\n tsk_size_t k;\n\n for (k = 0; k < result_dim; k++) {\n i = args.set_indexes[2 * k];\n j = args.set_indexes[2 * k + 1];\n ni = (double) args.sample_set_sizes[i];\n nj = (double) args.sample_set_sizes[j];\n denom = ni * nj * (nj - 1);\n result[k] = x[i] * (nj - x[j]) * (nj - x[j] - 1) / denom;\n }\n return 0;\n}\n\nint\ntsk_treeseq_Y2(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_windows,\n const double *windows, tsk_flags_t options, double *result)\n{\n int ret = 0;\n ret = check_sample_stat_inputs(num_sample_sets, 2, num_index_tuples, index_tuples);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_sample_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_index_tuples, index_tuples, Y2_summary_func, num_windows,\n windows, options, result);\nout:\n return ret;\n}\n\nstatic int\nf2_summary_func(tsk_size_t TSK_UNUSED(state_dim), const double *state,\n tsk_size_t result_dim, double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *x = state;\n double ni, nj, denom, numer;\n tsk_id_t i, j;\n tsk_size_t k;\n\n for (k = 0; k < result_dim; k++) {\n i = args.set_indexes[2 * k];\n j = args.set_indexes[2 * k + 1];\n ni = (double) args.sample_set_sizes[i];\n nj = (double) args.sample_set_sizes[j];\n denom = ni * (ni - 1) * nj * (nj - 1);\n numer = x[i] * (x[i] - 1) * (nj - x[j]) * (nj - x[j] - 1)\n - x[i] * (ni - x[i]) * (nj - x[j]) * x[j];\n result[k] = numer / denom;\n }\n return 0;\n}\n\nint\ntsk_treeseq_f2(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_windows,\n const double *windows, tsk_flags_t options, double *result)\n{\n int ret = 0;\n ret = check_sample_stat_inputs(num_sample_sets, 2, num_index_tuples, index_tuples);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_sample_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_index_tuples, index_tuples, f2_summary_func, num_windows,\n windows, options, result);\nout:\n return ret;\n}\n\nstatic int\nD2_ij_summary_func(tsk_size_t TSK_UNUSED(state_dim), const double *state,\n tsk_size_t result_dim, double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *state_row;\n double n;\n tsk_size_t k;\n tsk_id_t i, j;\n double p_A, p_B, p_AB, p_Ab, p_aB, D_i, D_j;\n\n for (k = 0; k < result_dim; k++) {\n i = args.set_indexes[2 * k];\n j = args.set_indexes[2 * k + 1];\n\n n = (double) args.sample_set_sizes[i];\n state_row = GET_2D_ROW(state, 3, i);\n p_AB = state_row[0] / n;\n p_Ab = state_row[1] / n;\n p_aB = state_row[2] / n;\n p_A = p_AB + p_Ab;\n p_B = p_AB + p_aB;\n D_i = p_AB - (p_A * p_B);\n\n n = (double) args.sample_set_sizes[j];\n state_row = GET_2D_ROW(state, 3, j);\n p_AB = state_row[0] / n;\n p_Ab = state_row[1] / n;\n p_aB = state_row[2] / n;\n p_A = p_AB + p_Ab;\n p_B = p_AB + p_aB;\n D_j = p_AB - (p_A * p_B);\n\n result[k] = D_i * D_j;\n }\n\n return 0;\n}\n\nint\ntsk_treeseq_D2_ij(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result)\n{\n int ret = 0;\n ret = check_sample_stat_inputs(num_sample_sets, 2, num_index_tuples, index_tuples);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_two_locus_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_index_tuples, index_tuples, D2_ij_summary_func,\n norm_total_weighted, num_rows, row_sites, row_positions, num_cols, col_sites,\n col_positions, options, result);\nout:\n return ret;\n}\n\nstatic int\nD2_ij_unbiased_summary_func(tsk_size_t TSK_UNUSED(state_dim), const double *state,\n tsk_size_t result_dim, double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *state_row;\n tsk_size_t k;\n tsk_id_t i, j;\n double n_i, n_j;\n double w_AB_i, w_Ab_i, w_aB_i, w_ab_i;\n double w_AB_j, w_Ab_j, w_aB_j, w_ab_j;\n\n for (k = 0; k < result_dim; k++) {\n i = args.set_indexes[2 * k];\n j = args.set_indexes[2 * k + 1];\n if (i == j) {\n // We require disjoint sample sets because we test equality here\n n_i = (double) args.sample_set_sizes[i];\n state_row = GET_2D_ROW(state, 3, i);\n w_AB_i = state_row[0];\n w_Ab_i = state_row[1];\n w_aB_i = state_row[2];\n w_ab_i = n_i - (w_AB_i + w_Ab_i + w_aB_i);\n result[k] = (w_AB_i * (w_AB_i - 1) * w_ab_i * (w_ab_i - 1)\n + w_Ab_i * (w_Ab_i - 1) * w_aB_i * (w_aB_i - 1)\n - 2 * w_AB_i * w_Ab_i * w_aB_i * w_ab_i)\n / n_i / (n_i - 1) / (n_i - 2) / (n_i - 3);\n }\n\n else {\n n_i = (double) args.sample_set_sizes[i];\n state_row = GET_2D_ROW(state, 3, i);\n w_AB_i = state_row[0];\n w_Ab_i = state_row[1];\n w_aB_i = state_row[2];\n w_ab_i = n_i - (w_AB_i + w_Ab_i + w_aB_i);\n\n n_j = (double) args.sample_set_sizes[j];\n state_row = GET_2D_ROW(state, 3, j);\n w_AB_j = state_row[0];\n w_Ab_j = state_row[1];\n w_aB_j = state_row[2];\n w_ab_j = n_j - (w_AB_j + w_Ab_j + w_aB_j);\n\n result[k] = (w_Ab_i * w_aB_i - w_AB_i * w_ab_i)\n * (w_Ab_j * w_aB_j - w_AB_j * w_ab_j) / n_i / (n_i - 1) / n_j\n / (n_j - 1);\n }\n }\n\n return 0;\n}\n\nint\ntsk_treeseq_D2_ij_unbiased(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result)\n{\n int ret = 0;\n ret = check_sample_stat_inputs(num_sample_sets, 2, num_index_tuples, index_tuples);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_two_locus_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_index_tuples, index_tuples, D2_ij_unbiased_summary_func,\n norm_total_weighted, num_rows, row_sites, row_positions, num_cols, col_sites,\n col_positions, options, result);\nout:\n return ret;\n}\n\nstatic int\nr2_ij_summary_func(tsk_size_t TSK_UNUSED(state_dim), const double *state,\n tsk_size_t result_dim, double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *state_row;\n tsk_size_t k;\n tsk_id_t i, j;\n double n, pAB, pAb, paB, pA, pB, D_i, D_j, denom_i, denom_j;\n\n for (k = 0; k < result_dim; k++) {\n i = args.set_indexes[2 * k];\n j = args.set_indexes[2 * k + 1];\n\n n = (double) args.sample_set_sizes[i];\n state_row = GET_2D_ROW(state, 3, i);\n pAB = state_row[0] / n;\n pAb = state_row[1] / n;\n paB = state_row[2] / n;\n pA = pAB + pAb;\n pB = pAB + paB;\n D_i = pAB - (pA * pB);\n denom_i = sqrt(pA * (1 - pA) * pB * (1 - pB));\n\n n = (double) args.sample_set_sizes[j];\n state_row = GET_2D_ROW(state, 3, j);\n pAB = state_row[0] / n;\n pAb = state_row[1] / n;\n paB = state_row[2] / n;\n pA = pAB + pAb;\n pB = pAB + paB;\n D_j = pAB - (pA * pB);\n denom_j = sqrt(pA * (1 - pA) * pB * (1 - pB));\n\n result[k] = (D_i * D_j) / (denom_i * denom_j);\n }\n return 0;\n}\n\nint\ntsk_treeseq_r2_ij(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result)\n{\n int ret = 0;\n ret = check_sample_stat_inputs(num_sample_sets, 2, num_index_tuples, index_tuples);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_two_locus_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_index_tuples, index_tuples, r2_ij_summary_func,\n norm_hap_weighted_ij, num_rows, row_sites, row_positions, num_cols, col_sites,\n col_positions, options, result);\nout:\n return ret;\n}\n\n/***********************************\n * Three way stats\n ***********************************/\n\nstatic int\nY3_summary_func(tsk_size_t TSK_UNUSED(state_dim), const double *state,\n tsk_size_t result_dim, double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *x = state;\n double ni, nj, nk, denom, numer;\n tsk_id_t i, j, k;\n tsk_size_t tuple_index;\n\n for (tuple_index = 0; tuple_index < result_dim; tuple_index++) {\n i = args.set_indexes[3 * tuple_index];\n j = args.set_indexes[3 * tuple_index + 1];\n k = args.set_indexes[3 * tuple_index + 2];\n ni = (double) args.sample_set_sizes[i];\n nj = (double) args.sample_set_sizes[j];\n nk = (double) args.sample_set_sizes[k];\n denom = ni * nj * nk;\n numer = x[i] * (nj - x[j]) * (nk - x[k]);\n result[tuple_index] = numer / denom;\n }\n return 0;\n}\n\nint\ntsk_treeseq_Y3(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_windows,\n const double *windows, tsk_flags_t options, double *result)\n{\n int ret = 0;\n ret = check_sample_stat_inputs(num_sample_sets, 3, num_index_tuples, index_tuples);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_sample_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_index_tuples, index_tuples, Y3_summary_func, num_windows,\n windows, options, result);\nout:\n return ret;\n}\n\nstatic int\nf3_summary_func(tsk_size_t TSK_UNUSED(state_dim), const double *state,\n tsk_size_t result_dim, double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *x = state;\n double ni, nj, nk, denom, numer;\n tsk_id_t i, j, k;\n tsk_size_t tuple_index;\n\n for (tuple_index = 0; tuple_index < result_dim; tuple_index++) {\n i = args.set_indexes[3 * tuple_index];\n j = args.set_indexes[3 * tuple_index + 1];\n k = args.set_indexes[3 * tuple_index + 2];\n ni = (double) args.sample_set_sizes[i];\n nj = (double) args.sample_set_sizes[j];\n nk = (double) args.sample_set_sizes[k];\n denom = ni * (ni - 1) * nj * nk;\n numer = x[i] * (x[i] - 1) * (nj - x[j]) * (nk - x[k])\n - x[i] * (ni - x[i]) * (nj - x[j]) * x[k];\n result[tuple_index] = numer / denom;\n }\n return 0;\n}\n\nint\ntsk_treeseq_f3(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_windows,\n const double *windows, tsk_flags_t options, double *result)\n{\n int ret = 0;\n ret = check_sample_stat_inputs(num_sample_sets, 3, num_index_tuples, index_tuples);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_sample_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_index_tuples, index_tuples, f3_summary_func, num_windows,\n windows, options, result);\nout:\n return ret;\n}\n\n/***********************************\n * Four way stats\n ***********************************/\n\nstatic int\nf4_summary_func(tsk_size_t TSK_UNUSED(state_dim), const double *state,\n tsk_size_t result_dim, double *result, void *params)\n{\n sample_count_stat_params_t args = *(sample_count_stat_params_t *) params;\n const double *x = state;\n double ni, nj, nk, nl, denom, numer;\n tsk_id_t i, j, k, l;\n tsk_size_t tuple_index;\n\n for (tuple_index = 0; tuple_index < result_dim; tuple_index++) {\n i = args.set_indexes[4 * tuple_index];\n j = args.set_indexes[4 * tuple_index + 1];\n k = args.set_indexes[4 * tuple_index + 2];\n l = args.set_indexes[4 * tuple_index + 3];\n ni = (double) args.sample_set_sizes[i];\n nj = (double) args.sample_set_sizes[j];\n nk = (double) args.sample_set_sizes[k];\n nl = (double) args.sample_set_sizes[l];\n denom = ni * nj * nk * nl;\n numer = x[i] * x[k] * (nj - x[j]) * (nl - x[l])\n - x[i] * x[l] * (nj - x[j]) * (nk - x[k]);\n result[tuple_index] = numer / denom;\n }\n return 0;\n}\n\nint\ntsk_treeseq_f4(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_windows,\n const double *windows, tsk_flags_t options, double *result)\n{\n int ret = 0;\n ret = check_sample_stat_inputs(num_sample_sets, 4, num_index_tuples, index_tuples);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_sample_count_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_index_tuples, index_tuples, f4_summary_func, num_windows,\n windows, options, result);\nout:\n return ret;\n}\n\n/* Error-raising getter functions */\n\nint TSK_WARN_UNUSED\ntsk_treeseq_get_node(const tsk_treeseq_t *self, tsk_id_t index, tsk_node_t *node)\n{\n return tsk_node_table_get_row(&self->tables->nodes, index, node);\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_get_edge(const tsk_treeseq_t *self, tsk_id_t index, tsk_edge_t *edge)\n{\n return tsk_edge_table_get_row(&self->tables->edges, index, edge);\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_get_migration(\n const tsk_treeseq_t *self, tsk_id_t index, tsk_migration_t *migration)\n{\n return tsk_migration_table_get_row(&self->tables->migrations, index, migration);\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_get_mutation(\n const tsk_treeseq_t *self, tsk_id_t index, tsk_mutation_t *mutation)\n{\n int ret = 0;\n\n ret = tsk_mutation_table_get_row(&self->tables->mutations, index, mutation);\n if (ret != 0) {\n goto out;\n }\n mutation->edge = self->site_mutations_mem[index].edge;\n mutation->inherited_state = self->site_mutations_mem[index].inherited_state;\n mutation->inherited_state_length\n = self->site_mutations_mem[index].inherited_state_length;\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_get_site(const tsk_treeseq_t *self, tsk_id_t index, tsk_site_t *site)\n{\n int ret = 0;\n\n ret = tsk_site_table_get_row(&self->tables->sites, index, site);\n if (ret != 0) {\n goto out;\n }\n site->mutations = self->site_mutations[index];\n site->mutations_length = self->site_mutations_length[index];\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_get_individual(\n const tsk_treeseq_t *self, tsk_id_t index, tsk_individual_t *individual)\n{\n int ret = 0;\n\n ret = tsk_individual_table_get_row(&self->tables->individuals, index, individual);\n if (ret != 0) {\n goto out;\n }\n individual->nodes = self->individual_nodes[index];\n individual->nodes_length = self->individual_nodes_length[index];\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_get_population(\n const tsk_treeseq_t *self, tsk_id_t index, tsk_population_t *population)\n{\n return tsk_population_table_get_row(&self->tables->populations, index, population);\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_get_provenance(\n const tsk_treeseq_t *self, tsk_id_t index, tsk_provenance_t *provenance)\n{\n return tsk_provenance_table_get_row(&self->tables->provenances, index, provenance);\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_simplify(const tsk_treeseq_t *self, const tsk_id_t *samples,\n tsk_size_t num_samples, tsk_flags_t options, tsk_treeseq_t *output,\n tsk_id_t *node_map)\n{\n int ret = 0;\n tsk_table_collection_t *tables = tsk_malloc(sizeof(*tables));\n\n if (tables == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n ret = tsk_treeseq_copy_tables(self, tables, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_table_collection_simplify(tables, samples, num_samples, options, node_map);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_init(\n output, tables, TSK_TS_INIT_BUILD_INDEXES | TSK_TAKE_OWNERSHIP);\n /* Once tsk_treeseq_init has returned ownership of tables is transferred */\n tables = NULL;\nout:\n if (tables != NULL) {\n tsk_table_collection_free(tables);\n tsk_safe_free(tables);\n }\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_split_edges(const tsk_treeseq_t *self, double time, tsk_flags_t flags,\n tsk_id_t population, const char *metadata, tsk_size_t metadata_length,\n tsk_flags_t TSK_UNUSED(options), tsk_treeseq_t *output)\n{\n int ret = 0;\n tsk_table_collection_t *tables = tsk_malloc(sizeof(*tables));\n const double *restrict node_time = self->tables->nodes.time;\n const tsk_size_t num_edges = self->tables->edges.num_rows;\n const tsk_size_t num_mutations = self->tables->mutations.num_rows;\n tsk_id_t *split_edge = tsk_malloc(num_edges * sizeof(*split_edge));\n tsk_id_t j, u, mapped_node, ret_id;\n double mutation_time;\n tsk_edge_t edge;\n tsk_mutation_t mutation;\n tsk_bookmark_t sort_start;\n\n memset(output, 0, sizeof(*output));\n if (split_edge == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n ret = tsk_treeseq_copy_tables(self, tables, 0);\n if (ret != 0) {\n goto out;\n }\n if (tables->migrations.num_rows > 0) {\n ret = tsk_trace_error(TSK_ERR_MIGRATIONS_NOT_SUPPORTED);\n goto out;\n }\n /* We could catch this below in add_row, but it's simpler to guarantee\n * that we always catch the error in corner cases where the values\n * aren't used. */\n if (population < -1 || population >= (tsk_id_t) self->tables->populations.num_rows) {\n ret = tsk_trace_error(TSK_ERR_POPULATION_OUT_OF_BOUNDS);\n goto out;\n }\n if (!tsk_isfinite(time)) {\n ret = tsk_trace_error(TSK_ERR_TIME_NONFINITE);\n goto out;\n }\n\n tsk_edge_table_clear(&tables->edges);\n tsk_memset(split_edge, TSK_NULL, num_edges * sizeof(*split_edge));\n\n for (j = 0; j < (tsk_id_t) num_edges; j++) {\n /* Would prefer to use tsk_edge_table_get_row_unsafe, but it's\n * currently static to tables.c */\n ret = tsk_edge_table_get_row(&self->tables->edges, j, &edge);\n tsk_bug_assert(ret == 0);\n if (node_time[edge.child] < time && time < node_time[edge.parent]) {\n u = tsk_node_table_add_row(&tables->nodes, flags, time, population, TSK_NULL,\n metadata, metadata_length);\n if (u < 0) {\n ret = (int) u;\n goto out;\n }\n ret_id = tsk_edge_table_add_row(&tables->edges, edge.left, edge.right, u,\n edge.child, edge.metadata, edge.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n edge.child = u;\n split_edge[j] = u;\n }\n ret_id = tsk_edge_table_add_row(&tables->edges, edge.left, edge.right,\n edge.parent, edge.child, edge.metadata, edge.metadata_length);\n if (ret_id < 0) {\n ret = (int) ret_id;\n goto out;\n }\n }\n\n for (j = 0; j < (tsk_id_t) num_mutations; j++) {\n /* Note: we could speed this up a bit by accessing the local\n * memory for mutations directly. */\n ret = tsk_treeseq_get_mutation(self, j, &mutation);\n tsk_bug_assert(ret == 0);\n mapped_node = TSK_NULL;\n if (mutation.edge != TSK_NULL) {\n mapped_node = split_edge[mutation.edge];\n }\n mutation_time = tsk_is_unknown_time(mutation.time) ? node_time[mutation.node]\n : mutation.time;\n if (mapped_node != TSK_NULL && mutation_time >= time) {\n /* Update the column in-place to save a bit of time. */\n tables->mutations.node[j] = mapped_node;\n }\n }\n\n /* Skip mutations and sites as they haven't been altered */\n /* Note we can probably optimise the edge sort a bit here also by\n * reasoning about when the first edge gets altered in the table.\n */\n memset(&sort_start, 0, sizeof(sort_start));\n sort_start.sites = tables->sites.num_rows;\n sort_start.mutations = tables->mutations.num_rows;\n ret = tsk_table_collection_sort(tables, &sort_start, 0);\n if (ret != 0) {\n goto out;\n }\n\n ret = tsk_treeseq_init(\n output, tables, TSK_TS_INIT_BUILD_INDEXES | TSK_TAKE_OWNERSHIP);\n tables = NULL;\nout:\n if (tables != NULL) {\n tsk_table_collection_free(tables);\n tsk_safe_free(tables);\n }\n tsk_safe_free(split_edge);\n return ret;\n}\n\n/* ======================================================== *\n * tree_position\n * ======================================================== */\n\nstatic void\ntsk_tree_position_set_null(tsk_tree_position_t *self)\n{\n self->index = -1;\n self->interval.left = 0;\n self->interval.right = 0;\n}\n\nint\ntsk_tree_position_init(tsk_tree_position_t *self, const tsk_treeseq_t *tree_sequence,\n tsk_flags_t TSK_UNUSED(options))\n{\n memset(self, 0, sizeof(*self));\n self->tree_sequence = tree_sequence;\n tsk_tree_position_set_null(self);\n return 0;\n}\n\nint\ntsk_tree_position_free(tsk_tree_position_t *TSK_UNUSED(self))\n{\n return 0;\n}\n\nint\ntsk_tree_position_print_state(const tsk_tree_position_t *self, FILE *out)\n{\n fprintf(out, \"Tree position state\\n\");\n fprintf(out, \"index = %d\\n\", (int) self->index);\n fprintf(out, \"interval = [%f,\\t%f)\\n\", self->interval.left, self->interval.right);\n fprintf(\n out, \"out = start=%d\\tstop=%d\\n\", (int) self->out.start, (int) self->out.stop);\n fprintf(\n out, \"in = start=%d\\tstop=%d\\n\", (int) self->in.start, (int) self->in.stop);\n return 0;\n}\n\nbool\ntsk_tree_position_next(tsk_tree_position_t *self)\n{\n const tsk_table_collection_t *tables = self->tree_sequence->tables;\n const tsk_id_t M = (tsk_id_t) tables->edges.num_rows;\n const tsk_id_t num_trees = (tsk_id_t) self->tree_sequence->num_trees;\n const double *restrict left_coords = tables->edges.left;\n const tsk_id_t *restrict left_order = tables->indexes.edge_insertion_order;\n const double *restrict right_coords = tables->edges.right;\n const tsk_id_t *restrict right_order = tables->indexes.edge_removal_order;\n const double *restrict breakpoints = self->tree_sequence->breakpoints;\n tsk_id_t j, left_current_index, right_current_index;\n double left;\n\n if (self->index == -1) {\n self->interval.right = 0;\n self->in.stop = 0;\n self->out.stop = 0;\n self->direction = TSK_DIR_FORWARD;\n }\n\n if (self->direction == TSK_DIR_FORWARD) {\n left_current_index = self->in.stop;\n right_current_index = self->out.stop;\n } else {\n left_current_index = self->out.stop + 1;\n right_current_index = self->in.stop + 1;\n }\n\n left = self->interval.right;\n\n j = right_current_index;\n self->out.start = j;\n while (j < M && right_coords[right_order[j]] == left) {\n j++;\n }\n self->out.stop = j;\n self->out.order = right_order;\n\n j = left_current_index;\n self->in.start = j;\n while (j < M && left_coords[left_order[j]] == left) {\n j++;\n }\n self->in.stop = j;\n self->in.order = left_order;\n\n self->direction = TSK_DIR_FORWARD;\n self->index++;\n if (self->index == num_trees) {\n tsk_tree_position_set_null(self);\n } else {\n self->interval.left = left;\n self->interval.right = breakpoints[self->index + 1];\n }\n return self->index != -1;\n}\n\nbool\ntsk_tree_position_prev(tsk_tree_position_t *self)\n{\n const tsk_table_collection_t *tables = self->tree_sequence->tables;\n const tsk_id_t M = (tsk_id_t) tables->edges.num_rows;\n const double sequence_length = tables->sequence_length;\n const tsk_id_t num_trees = (tsk_id_t) self->tree_sequence->num_trees;\n const double *restrict left_coords = tables->edges.left;\n const tsk_id_t *restrict left_order = tables->indexes.edge_insertion_order;\n const double *restrict right_coords = tables->edges.right;\n const tsk_id_t *restrict right_order = tables->indexes.edge_removal_order;\n const double *restrict breakpoints = self->tree_sequence->breakpoints;\n tsk_id_t j, left_current_index, right_current_index;\n double right;\n\n if (self->index == -1) {\n self->index = num_trees;\n self->interval.left = sequence_length;\n self->in.stop = M - 1;\n self->out.stop = M - 1;\n self->direction = TSK_DIR_REVERSE;\n }\n\n if (self->direction == TSK_DIR_REVERSE) {\n left_current_index = self->out.stop;\n right_current_index = self->in.stop;\n } else {\n left_current_index = self->in.stop - 1;\n right_current_index = self->out.stop - 1;\n }\n\n right = self->interval.left;\n\n j = left_current_index;\n self->out.start = j;\n while (j >= 0 && left_coords[left_order[j]] == right) {\n j--;\n }\n self->out.stop = j;\n self->out.order = left_order;\n\n j = right_current_index;\n self->in.start = j;\n while (j >= 0 && right_coords[right_order[j]] == right) {\n j--;\n }\n self->in.stop = j;\n self->in.order = right_order;\n\n self->index--;\n self->direction = TSK_DIR_REVERSE;\n if (self->index == -1) {\n tsk_tree_position_set_null(self);\n } else {\n self->interval.left = breakpoints[self->index];\n self->interval.right = right;\n }\n return self->index != -1;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_position_seek_forward(tsk_tree_position_t *self, tsk_id_t index)\n{\n int ret = 0;\n const tsk_table_collection_t *tables = self->tree_sequence->tables;\n const tsk_id_t M = (tsk_id_t) tables->edges.num_rows;\n const tsk_id_t num_trees = (tsk_id_t) self->tree_sequence->num_trees;\n const double *restrict left_coords = tables->edges.left;\n const tsk_id_t *restrict left_order = tables->indexes.edge_insertion_order;\n const double *restrict right_coords = tables->edges.right;\n const tsk_id_t *restrict right_order = tables->indexes.edge_removal_order;\n const double *restrict breakpoints = self->tree_sequence->breakpoints;\n tsk_id_t j, left_current_index, right_current_index;\n double left;\n\n tsk_bug_assert(index >= self->index && index < num_trees);\n\n if (self->index == -1) {\n self->interval.right = 0;\n self->in.stop = 0;\n self->out.stop = 0;\n self->direction = TSK_DIR_FORWARD;\n }\n\n if (self->direction == TSK_DIR_FORWARD) {\n left_current_index = self->in.stop;\n right_current_index = self->out.stop;\n } else {\n left_current_index = self->out.stop + 1;\n right_current_index = self->in.stop + 1;\n }\n\n self->direction = TSK_DIR_FORWARD;\n left = breakpoints[index];\n\n j = right_current_index;\n self->out.start = j;\n while (j < M && right_coords[right_order[j]] <= left) {\n j++;\n }\n self->out.stop = j;\n\n if (self->index == -1) {\n self->out.start = self->out.stop;\n }\n\n j = left_current_index;\n while (j < M && right_coords[left_order[j]] <= left) {\n j++;\n }\n self->in.start = j;\n while (j < M && left_coords[left_order[j]] <= left) {\n j++;\n }\n self->in.stop = j;\n\n self->interval.left = left;\n self->interval.right = breakpoints[index + 1];\n self->out.order = right_order;\n self->in.order = left_order;\n self->index = index;\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_position_seek_backward(tsk_tree_position_t *self, tsk_id_t index)\n{\n int ret = 0;\n const tsk_table_collection_t *tables = self->tree_sequence->tables;\n const tsk_id_t M = (tsk_id_t) tables->edges.num_rows;\n const double sequence_length = tables->sequence_length;\n const tsk_id_t num_trees = (tsk_id_t) self->tree_sequence->num_trees;\n const double *restrict left_coords = tables->edges.left;\n const tsk_id_t *restrict left_order = tables->indexes.edge_insertion_order;\n const double *restrict right_coords = tables->edges.right;\n const tsk_id_t *restrict right_order = tables->indexes.edge_removal_order;\n const double *restrict breakpoints = self->tree_sequence->breakpoints;\n tsk_id_t j, left_current_index, right_current_index;\n double right;\n\n if (self->index == -1) {\n self->index = num_trees;\n self->interval.left = sequence_length;\n self->in.stop = M - 1;\n self->out.stop = M - 1;\n self->direction = TSK_DIR_REVERSE;\n }\n tsk_bug_assert(index <= self->index);\n\n if (self->direction == TSK_DIR_REVERSE) {\n left_current_index = self->out.stop;\n right_current_index = self->in.stop;\n } else {\n left_current_index = self->in.stop - 1;\n right_current_index = self->out.stop - 1;\n }\n\n self->direction = TSK_DIR_REVERSE;\n right = breakpoints[index + 1];\n\n j = left_current_index;\n self->out.start = j;\n while (j >= 0 && left_coords[left_order[j]] >= right) {\n j--;\n }\n self->out.stop = j;\n\n if (self->index == num_trees) {\n self->out.start = self->out.stop;\n }\n\n j = right_current_index;\n while (j >= 0 && left_coords[right_order[j]] >= right) {\n j--;\n }\n self->in.start = j;\n while (j >= 0 && right_coords[right_order[j]] >= right) {\n j--;\n }\n self->in.stop = j;\n\n self->interval.right = right;\n self->interval.left = breakpoints[index];\n self->out.order = left_order;\n self->in.order = right_order;\n self->index = index;\n\n return ret;\n}\n\n/* ======================================================== *\n * Tree\n * ======================================================== */\n\n/* Return the root for the specified node.\n * NOTE: no bounds checking is done here.\n */\nstatic tsk_id_t\ntsk_tree_get_node_root(const tsk_tree_t *self, tsk_id_t u)\n{\n const tsk_id_t *restrict parent = self->parent;\n\n while (parent[u] != TSK_NULL) {\n u = parent[u];\n }\n return u;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_init(tsk_tree_t *self, const tsk_treeseq_t *tree_sequence, tsk_flags_t options)\n{\n int ret = 0;\n tsk_size_t num_samples, num_nodes, N;\n\n tsk_memset(self, 0, sizeof(tsk_tree_t));\n if (tree_sequence == NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n num_nodes = tree_sequence->tables->nodes.num_rows;\n num_samples = tree_sequence->num_samples;\n self->num_nodes = num_nodes;\n self->virtual_root = (tsk_id_t) num_nodes;\n self->tree_sequence = tree_sequence;\n self->samples = tree_sequence->samples;\n self->options = options;\n self->root_threshold = 1;\n\n /* Allocate space in the quintuply linked tree for the virtual root */\n N = num_nodes + 1;\n self->parent = tsk_malloc(N * sizeof(*self->parent));\n self->left_child = tsk_malloc(N * sizeof(*self->left_child));\n self->right_child = tsk_malloc(N * sizeof(*self->right_child));\n self->left_sib = tsk_malloc(N * sizeof(*self->left_sib));\n self->right_sib = tsk_malloc(N * sizeof(*self->right_sib));\n self->num_children = tsk_calloc(N, sizeof(*self->num_children));\n self->edge = tsk_malloc(N * sizeof(*self->edge));\n if (self->parent == NULL || self->left_child == NULL || self->right_child == NULL\n || self->left_sib == NULL || self->right_sib == NULL\n || self->num_children == NULL || self->edge == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n if (!(self->options & TSK_NO_SAMPLE_COUNTS)) {\n self->num_samples = tsk_calloc(N, sizeof(*self->num_samples));\n self->num_tracked_samples = tsk_calloc(N, sizeof(*self->num_tracked_samples));\n if (self->num_samples == NULL || self->num_tracked_samples == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n }\n if (self->options & TSK_SAMPLE_LISTS) {\n self->left_sample = tsk_malloc(N * sizeof(*self->left_sample));\n self->right_sample = tsk_malloc(N * sizeof(*self->right_sample));\n self->next_sample = tsk_malloc(num_samples * sizeof(*self->next_sample));\n if (self->left_sample == NULL || self->right_sample == NULL\n || self->next_sample == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n }\n\n ret = tsk_tree_position_init(&self->tree_pos, tree_sequence, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_tree_clear(self);\nout:\n return ret;\n}\n\nint\ntsk_tree_set_root_threshold(tsk_tree_t *self, tsk_size_t root_threshold)\n{\n int ret = 0;\n\n if (root_threshold == 0) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n /* Don't allow the value to be set when the tree is out of the null\n * state */\n if (self->index != -1) {\n ret = tsk_trace_error(TSK_ERR_UNSUPPORTED_OPERATION);\n goto out;\n }\n self->root_threshold = root_threshold;\n /* Reset the roots */\n ret = tsk_tree_clear(self);\nout:\n return ret;\n}\n\ntsk_size_t\ntsk_tree_get_root_threshold(const tsk_tree_t *self)\n{\n return self->root_threshold;\n}\n\nint\ntsk_tree_free(tsk_tree_t *self)\n{\n tsk_safe_free(self->parent);\n tsk_safe_free(self->left_child);\n tsk_safe_free(self->right_child);\n tsk_safe_free(self->left_sib);\n tsk_safe_free(self->right_sib);\n tsk_safe_free(self->num_samples);\n tsk_safe_free(self->num_tracked_samples);\n tsk_safe_free(self->left_sample);\n tsk_safe_free(self->right_sample);\n tsk_safe_free(self->next_sample);\n tsk_safe_free(self->num_children);\n tsk_safe_free(self->edge);\n tsk_tree_position_free(&self->tree_pos);\n return 0;\n}\n\nbool\ntsk_tree_has_sample_lists(const tsk_tree_t *self)\n{\n return !!(self->options & TSK_SAMPLE_LISTS);\n}\n\nbool\ntsk_tree_has_sample_counts(const tsk_tree_t *self)\n{\n return !(self->options & TSK_NO_SAMPLE_COUNTS);\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_tree_reset_tracked_samples(tsk_tree_t *self)\n{\n int ret = 0;\n\n if (!tsk_tree_has_sample_counts(self)) {\n ret = tsk_trace_error(TSK_ERR_UNSUPPORTED_OPERATION);\n goto out;\n }\n tsk_memset(self->num_tracked_samples, 0,\n (self->num_nodes + 1) * sizeof(*self->num_tracked_samples));\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_set_tracked_samples(\n tsk_tree_t *self, tsk_size_t num_tracked_samples, const tsk_id_t *tracked_samples)\n{\n int ret = TSK_ERR_GENERIC;\n tsk_size_t *tree_num_tracked_samples = self->num_tracked_samples;\n const tsk_id_t *parent = self->parent;\n tsk_size_t j;\n tsk_id_t u;\n\n /* TODO This is not needed when the tree is new. We should use the\n * state machine to check and only reset the tracked samples when needed.\n */\n ret = tsk_tree_reset_tracked_samples(self);\n if (ret != 0) {\n goto out;\n }\n self->num_tracked_samples[self->virtual_root] = num_tracked_samples;\n for (j = 0; j < num_tracked_samples; j++) {\n u = tracked_samples[j];\n if (u < 0 || u >= (tsk_id_t) self->num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n if (!tsk_treeseq_is_sample(self->tree_sequence, u)) {\n ret = tsk_trace_error(TSK_ERR_BAD_SAMPLES);\n goto out;\n }\n if (self->num_tracked_samples[u] != 0) {\n ret = tsk_trace_error(TSK_ERR_DUPLICATE_SAMPLE);\n goto out;\n }\n /* Propagate this upwards */\n while (u != TSK_NULL) {\n tree_num_tracked_samples[u]++;\n u = parent[u];\n }\n }\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_track_descendant_samples(tsk_tree_t *self, tsk_id_t node)\n{\n int ret = 0;\n tsk_id_t *nodes = tsk_malloc(tsk_tree_get_size_bound(self) * sizeof(*nodes));\n const tsk_id_t *restrict parent = self->parent;\n const tsk_id_t *restrict left_child = self->left_child;\n const tsk_id_t *restrict right_sib = self->right_sib;\n const tsk_flags_t *restrict flags = self->tree_sequence->tables->nodes.flags;\n tsk_size_t *num_tracked_samples = self->num_tracked_samples;\n tsk_size_t n, j, num_nodes;\n tsk_id_t u, v;\n\n if (nodes == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n ret = tsk_tree_postorder_from(self, node, nodes, &num_nodes);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_tree_reset_tracked_samples(self);\n if (ret != 0) {\n goto out;\n }\n u = 0; /* keep the compiler happy */\n for (j = 0; j < num_nodes; j++) {\n u = nodes[j];\n for (v = left_child[u]; v != TSK_NULL; v = right_sib[v]) {\n num_tracked_samples[u] += num_tracked_samples[v];\n }\n num_tracked_samples[u] += flags[u] & TSK_NODE_IS_SAMPLE ? 1 : 0;\n }\n n = num_tracked_samples[u];\n u = parent[u];\n while (u != TSK_NULL) {\n num_tracked_samples[u] = n;\n u = parent[u];\n }\n num_tracked_samples[self->virtual_root] = n;\nout:\n tsk_safe_free(nodes);\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_copy(const tsk_tree_t *self, tsk_tree_t *dest, tsk_flags_t options)\n{\n int ret = TSK_ERR_GENERIC;\n tsk_size_t N = self->num_nodes + 1;\n\n if (!(options & TSK_NO_INIT)) {\n ret = tsk_tree_init(dest, self->tree_sequence, options);\n if (ret != 0) {\n goto out;\n }\n }\n if (self->tree_sequence != dest->tree_sequence) {\n ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);\n goto out;\n }\n dest->interval = self->interval;\n dest->left_index = self->left_index;\n dest->right_index = self->right_index;\n dest->direction = self->direction;\n dest->index = self->index;\n dest->sites = self->sites;\n dest->sites_length = self->sites_length;\n dest->root_threshold = self->root_threshold;\n dest->num_edges = self->num_edges;\n dest->tree_pos = self->tree_pos;\n\n tsk_memcpy(dest->parent, self->parent, N * sizeof(*self->parent));\n tsk_memcpy(dest->left_child, self->left_child, N * sizeof(*self->left_child));\n tsk_memcpy(dest->right_child, self->right_child, N * sizeof(*self->right_child));\n tsk_memcpy(dest->left_sib, self->left_sib, N * sizeof(*self->left_sib));\n tsk_memcpy(dest->right_sib, self->right_sib, N * sizeof(*self->right_sib));\n tsk_memcpy(dest->num_children, self->num_children, N * sizeof(*self->num_children));\n tsk_memcpy(dest->edge, self->edge, N * sizeof(*self->edge));\n if (!(dest->options & TSK_NO_SAMPLE_COUNTS)) {\n if (self->options & TSK_NO_SAMPLE_COUNTS) {\n ret = tsk_trace_error(TSK_ERR_UNSUPPORTED_OPERATION);\n goto out;\n }\n tsk_memcpy(dest->num_samples, self->num_samples, N * sizeof(*self->num_samples));\n tsk_memcpy(dest->num_tracked_samples, self->num_tracked_samples,\n N * sizeof(*self->num_tracked_samples));\n }\n if (dest->options & TSK_SAMPLE_LISTS) {\n if (!(self->options & TSK_SAMPLE_LISTS)) {\n ret = tsk_trace_error(TSK_ERR_UNSUPPORTED_OPERATION);\n goto out;\n }\n tsk_memcpy(dest->left_sample, self->left_sample, N * sizeof(*self->left_sample));\n tsk_memcpy(\n dest->right_sample, self->right_sample, N * sizeof(*self->right_sample));\n tsk_memcpy(dest->next_sample, self->next_sample,\n self->tree_sequence->num_samples * sizeof(*self->next_sample));\n }\n ret = 0;\nout:\n return ret;\n}\n\nbool TSK_WARN_UNUSED\ntsk_tree_equals(const tsk_tree_t *self, const tsk_tree_t *other)\n{\n bool ret = false;\n\n if (self->tree_sequence == other->tree_sequence) {\n ret = self->index == other->index;\n }\n return ret;\n}\n\nstatic int\ntsk_tree_check_node(const tsk_tree_t *self, tsk_id_t u)\n{\n int ret = 0;\n if (u < 0 || u > (tsk_id_t) self->num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n }\n return ret;\n}\n\nbool\ntsk_tree_is_descendant(const tsk_tree_t *self, tsk_id_t u, tsk_id_t v)\n{\n bool ret = false;\n tsk_id_t w = u;\n tsk_id_t *restrict parent = self->parent;\n\n if (tsk_tree_check_node(self, u) == 0 && tsk_tree_check_node(self, v) == 0) {\n while (w != v && w != TSK_NULL) {\n w = parent[w];\n }\n ret = w == v;\n }\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_get_mrca(const tsk_tree_t *self, tsk_id_t u, tsk_id_t v, tsk_id_t *mrca)\n{\n int ret = 0;\n double tu, tv;\n const tsk_id_t *restrict parent = self->parent;\n const double *restrict time = self->tree_sequence->tables->nodes.time;\n\n ret = tsk_tree_check_node(self, u);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_tree_check_node(self, v);\n if (ret != 0) {\n goto out;\n }\n\n /* Simplest to make the virtual_root a special case here to avoid\n * doing the time lookup. */\n if (u == self->virtual_root || v == self->virtual_root) {\n *mrca = self->virtual_root;\n return 0;\n }\n\n tu = time[u];\n tv = time[v];\n while (u != v) {\n if (tu < tv) {\n u = parent[u];\n if (u == TSK_NULL) {\n break;\n }\n tu = time[u];\n } else {\n v = parent[v];\n if (v == TSK_NULL) {\n break;\n }\n tv = time[v];\n }\n }\n *mrca = u == v ? u : TSK_NULL;\nout:\n return ret;\n}\n\nstatic int\ntsk_tree_get_num_samples_by_traversal(\n const tsk_tree_t *self, tsk_id_t u, tsk_size_t *num_samples)\n{\n int ret = 0;\n tsk_size_t num_nodes, j;\n tsk_size_t count = 0;\n const tsk_flags_t *restrict flags = self->tree_sequence->tables->nodes.flags;\n tsk_id_t *nodes = tsk_malloc(tsk_tree_get_size_bound(self) * sizeof(*nodes));\n tsk_id_t v;\n\n if (nodes == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n ret = tsk_tree_preorder_from(self, u, nodes, &num_nodes);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_nodes; j++) {\n v = nodes[j];\n if (flags[v] & TSK_NODE_IS_SAMPLE) {\n count++;\n }\n }\n *num_samples = count;\nout:\n tsk_safe_free(nodes);\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_get_num_samples(const tsk_tree_t *self, tsk_id_t u, tsk_size_t *num_samples)\n{\n int ret = 0;\n\n ret = tsk_tree_check_node(self, u);\n if (ret != 0) {\n goto out;\n }\n\n if (!(self->options & TSK_NO_SAMPLE_COUNTS)) {\n *num_samples = (tsk_size_t) self->num_samples[u];\n } else {\n ret = tsk_tree_get_num_samples_by_traversal(self, u, num_samples);\n }\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_get_num_tracked_samples(\n const tsk_tree_t *self, tsk_id_t u, tsk_size_t *num_tracked_samples)\n{\n int ret = 0;\n\n ret = tsk_tree_check_node(self, u);\n if (ret != 0) {\n goto out;\n }\n if (self->options & TSK_NO_SAMPLE_COUNTS) {\n ret = tsk_trace_error(TSK_ERR_UNSUPPORTED_OPERATION);\n goto out;\n }\n *num_tracked_samples = self->num_tracked_samples[u];\nout:\n return ret;\n}\n\nbool\ntsk_tree_is_sample(const tsk_tree_t *self, tsk_id_t u)\n{\n return tsk_treeseq_is_sample(self->tree_sequence, u);\n}\n\ntsk_id_t\ntsk_tree_get_left_root(const tsk_tree_t *self)\n{\n return self->left_child[self->virtual_root];\n}\n\ntsk_id_t\ntsk_tree_get_right_root(const tsk_tree_t *self)\n{\n return self->right_child[self->virtual_root];\n}\n\ntsk_size_t\ntsk_tree_get_num_roots(const tsk_tree_t *self)\n{\n return (tsk_size_t) self->num_children[self->virtual_root];\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_get_parent(const tsk_tree_t *self, tsk_id_t u, tsk_id_t *parent)\n{\n int ret = 0;\n\n ret = tsk_tree_check_node(self, u);\n if (ret != 0) {\n goto out;\n }\n *parent = self->parent[u];\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_get_time(const tsk_tree_t *self, tsk_id_t u, double *t)\n{\n int ret = 0;\n tsk_node_t node;\n\n if (u == self->virtual_root) {\n *t = INFINITY;\n } else {\n ret = tsk_treeseq_get_node(self->tree_sequence, u, &node);\n if (ret != 0) {\n goto out;\n }\n *t = node.time;\n }\nout:\n return ret;\n}\n\nstatic inline double\ntsk_tree_get_branch_length_unsafe(const tsk_tree_t *self, tsk_id_t u)\n{\n const double *times = self->tree_sequence->tables->nodes.time;\n const tsk_id_t parent = self->parent[u];\n\n return parent == TSK_NULL ? 0 : times[parent] - times[u];\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_get_branch_length(const tsk_tree_t *self, tsk_id_t u, double *ret_branch_length)\n{\n int ret = 0;\n\n ret = tsk_tree_check_node(self, u);\n if (ret != 0) {\n goto out;\n }\n *ret_branch_length = tsk_tree_get_branch_length_unsafe(self, u);\nout:\n return ret;\n}\n\nint\ntsk_tree_get_total_branch_length(const tsk_tree_t *self, tsk_id_t node, double *ret_tbl)\n{\n int ret = 0;\n tsk_size_t j, num_nodes;\n tsk_id_t u, v;\n const tsk_id_t *restrict parent = self->parent;\n const double *restrict time = self->tree_sequence->tables->nodes.time;\n tsk_id_t *nodes = tsk_malloc(tsk_tree_get_size_bound(self) * sizeof(*nodes));\n double sum = 0;\n\n if (nodes == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n ret = tsk_tree_preorder_from(self, node, nodes, &num_nodes);\n if (ret != 0) {\n goto out;\n }\n /* We always skip the first node because we don't return the branch length\n * over the input node. */\n for (j = 1; j < num_nodes; j++) {\n u = nodes[j];\n v = parent[u];\n if (v != TSK_NULL) {\n sum += time[v] - time[u];\n }\n }\n *ret_tbl = sum;\nout:\n tsk_safe_free(nodes);\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_get_sites(\n const tsk_tree_t *self, const tsk_site_t **sites, tsk_size_t *sites_length)\n{\n *sites = self->sites;\n *sites_length = self->sites_length;\n return 0;\n}\n\n/* u must be a valid node in the tree. For internal use */\nstatic int\ntsk_tree_get_depth_unsafe(const tsk_tree_t *self, tsk_id_t u)\n{\n tsk_id_t v;\n const tsk_id_t *restrict parent = self->parent;\n int depth = 0;\n\n if (u == self->virtual_root) {\n return -1;\n }\n for (v = parent[u]; v != TSK_NULL; v = parent[v]) {\n depth++;\n }\n return depth;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_get_depth(const tsk_tree_t *self, tsk_id_t u, int *depth_ret)\n{\n int ret = 0;\n\n ret = tsk_tree_check_node(self, u);\n if (ret != 0) {\n goto out;\n }\n\n *depth_ret = tsk_tree_get_depth_unsafe(self, u);\nout:\n return ret;\n}\n\nstatic tsk_id_t\ntsk_tree_node_root(tsk_tree_t *self, tsk_id_t u)\n{\n tsk_id_t v = u;\n while (self->parent[v] != TSK_NULL) {\n v = self->parent[v];\n }\n\n return v;\n}\n\nstatic void\ntsk_tree_check_state(const tsk_tree_t *self)\n{\n tsk_id_t u, v;\n tsk_size_t j, num_samples;\n int err, c;\n tsk_site_t site;\n tsk_id_t *children = tsk_malloc(self->num_nodes * sizeof(tsk_id_t));\n bool *is_root = tsk_calloc(self->num_nodes, sizeof(bool));\n\n tsk_bug_assert(children != NULL);\n\n /* Check the virtual root properties */\n tsk_bug_assert(self->parent[self->virtual_root] == TSK_NULL);\n tsk_bug_assert(self->left_sib[self->virtual_root] == TSK_NULL);\n tsk_bug_assert(self->right_sib[self->virtual_root] == TSK_NULL);\n\n for (j = 0; j < self->tree_sequence->num_samples; j++) {\n u = self->samples[j];\n while (self->parent[u] != TSK_NULL) {\n u = self->parent[u];\n }\n is_root[u] = true;\n }\n if (self->tree_sequence->num_samples == 0) {\n tsk_bug_assert(self->left_child[self->virtual_root] == TSK_NULL);\n }\n\n /* Iterate over the roots and make sure they are set */\n for (u = tsk_tree_get_left_root(self); u != TSK_NULL; u = self->right_sib[u]) {\n tsk_bug_assert(is_root[u]);\n is_root[u] = false;\n }\n for (u = 0; u < (tsk_id_t) self->num_nodes; u++) {\n tsk_bug_assert(!is_root[u]);\n c = 0;\n for (v = self->left_child[u]; v != TSK_NULL; v = self->right_sib[v]) {\n tsk_bug_assert(self->parent[v] == u);\n children[c] = v;\n c++;\n }\n for (v = self->right_child[u]; v != TSK_NULL; v = self->left_sib[v]) {\n tsk_bug_assert(c > 0);\n c--;\n tsk_bug_assert(v == children[c]);\n }\n }\n for (j = 0; j < self->sites_length; j++) {\n site = self->sites[j];\n tsk_bug_assert(self->interval.left <= site.position);\n tsk_bug_assert(site.position < self->interval.right);\n }\n\n if (!(self->options & TSK_NO_SAMPLE_COUNTS)) {\n tsk_bug_assert(self->num_samples != NULL);\n tsk_bug_assert(self->num_tracked_samples != NULL);\n for (u = 0; u < (tsk_id_t) self->num_nodes; u++) {\n err = tsk_tree_get_num_samples_by_traversal(self, u, &num_samples);\n tsk_bug_assert(err == 0);\n tsk_bug_assert(num_samples == (tsk_size_t) self->num_samples[u]);\n }\n } else {\n tsk_bug_assert(self->num_samples == NULL);\n tsk_bug_assert(self->num_tracked_samples == NULL);\n }\n if (self->options & TSK_SAMPLE_LISTS) {\n tsk_bug_assert(self->right_sample != NULL);\n tsk_bug_assert(self->left_sample != NULL);\n tsk_bug_assert(self->next_sample != NULL);\n } else {\n tsk_bug_assert(self->right_sample == NULL);\n tsk_bug_assert(self->left_sample == NULL);\n tsk_bug_assert(self->next_sample == NULL);\n }\n\n free(children);\n free(is_root);\n}\n\nvoid\ntsk_tree_print_state(const tsk_tree_t *self, FILE *out)\n{\n tsk_size_t j;\n tsk_site_t site;\n\n fprintf(out, \"Tree state:\\n\");\n fprintf(out, \"options = %d\\n\", self->options);\n fprintf(out, \"root_threshold = %lld\\n\", (long long) self->root_threshold);\n fprintf(out, \"left = %f\\n\", self->interval.left);\n fprintf(out, \"right = %f\\n\", self->interval.right);\n fprintf(out, \"index = %lld\\n\", (long long) self->index);\n fprintf(out, \"num_edges = %d\\n\", (int) self->num_edges);\n fprintf(out, \"node\\tedge\\tparent\\tlchild\\trchild\\tlsib\\trsib\");\n if (self->options & TSK_SAMPLE_LISTS) {\n fprintf(out, \"\\thead\\ttail\");\n }\n fprintf(out, \"\\n\");\n\n for (j = 0; j < self->num_nodes + 1; j++) {\n fprintf(out, \"%lld\\t%lld\\t%lld\\t%lld\\t%lld\\t%lld\\t%lld\", (long long) j,\n (long long) self->edge[j], (long long) self->parent[j],\n (long long) self->left_child[j], (long long) self->right_child[j],\n (long long) self->left_sib[j], (long long) self->right_sib[j]);\n if (self->options & TSK_SAMPLE_LISTS) {\n fprintf(out, \"\\t%lld\\t%lld\\t\", (long long) self->left_sample[j],\n (long long) self->right_sample[j]);\n }\n if (!(self->options & TSK_NO_SAMPLE_COUNTS)) {\n fprintf(out, \"\\t%lld\\t%lld\", (long long) self->num_samples[j],\n (long long) self->num_tracked_samples[j]);\n }\n fprintf(out, \"\\n\");\n }\n fprintf(out, \"sites = \\n\");\n for (j = 0; j < self->sites_length; j++) {\n site = self->sites[j];\n fprintf(out, \"\\t%lld\\t%f\\n\", (long long) site.id, site.position);\n }\n tsk_tree_check_state(self);\n}\n\n/* Methods for positioning the tree along the sequence */\n\n/* The following methods are performance sensitive and so we use a\n * lot of restrict pointers. Because we are saying that we don't have\n * any aliases to these pointers, we pass around the reference to parent\n * since it's used in all the functions. */\nstatic inline void\ntsk_tree_update_sample_lists(\n tsk_tree_t *self, tsk_id_t node, const tsk_id_t *restrict parent)\n{\n tsk_id_t u, v, sample_index;\n tsk_id_t *restrict left_child = self->left_child;\n tsk_id_t *restrict right_sib = self->right_sib;\n tsk_id_t *restrict left = self->left_sample;\n tsk_id_t *restrict right = self->right_sample;\n tsk_id_t *restrict next = self->next_sample;\n const tsk_id_t *restrict sample_index_map = self->tree_sequence->sample_index_map;\n\n for (u = node; u != TSK_NULL; u = parent[u]) {\n sample_index = sample_index_map[u];\n if (sample_index != TSK_NULL) {\n right[u] = left[u];\n } else {\n left[u] = TSK_NULL;\n right[u] = TSK_NULL;\n }\n for (v = left_child[u]; v != TSK_NULL; v = right_sib[v]) {\n if (left[v] != TSK_NULL) {\n tsk_bug_assert(right[v] != TSK_NULL);\n if (left[u] == TSK_NULL) {\n left[u] = left[v];\n right[u] = right[v];\n } else {\n next[right[u]] = left[v];\n right[u] = right[v];\n }\n }\n }\n }\n}\n\nstatic inline void\ntsk_tree_remove_branch(\n tsk_tree_t *self, tsk_id_t p, tsk_id_t c, tsk_id_t *restrict parent)\n{\n tsk_id_t *restrict left_child = self->left_child;\n tsk_id_t *restrict right_child = self->right_child;\n tsk_id_t *restrict left_sib = self->left_sib;\n tsk_id_t *restrict right_sib = self->right_sib;\n tsk_id_t *restrict num_children = self->num_children;\n tsk_id_t lsib = left_sib[c];\n tsk_id_t rsib = right_sib[c];\n\n if (lsib == TSK_NULL) {\n left_child[p] = rsib;\n } else {\n right_sib[lsib] = rsib;\n }\n if (rsib == TSK_NULL) {\n right_child[p] = lsib;\n } else {\n left_sib[rsib] = lsib;\n }\n parent[c] = TSK_NULL;\n left_sib[c] = TSK_NULL;\n right_sib[c] = TSK_NULL;\n num_children[p]--;\n}\n\nstatic inline void\ntsk_tree_insert_branch(\n tsk_tree_t *self, tsk_id_t p, tsk_id_t c, tsk_id_t *restrict parent)\n{\n tsk_id_t *restrict left_child = self->left_child;\n tsk_id_t *restrict right_child = self->right_child;\n tsk_id_t *restrict left_sib = self->left_sib;\n tsk_id_t *restrict right_sib = self->right_sib;\n tsk_id_t *restrict num_children = self->num_children;\n tsk_id_t u;\n\n parent[c] = p;\n u = right_child[p];\n if (u == TSK_NULL) {\n left_child[p] = c;\n left_sib[c] = TSK_NULL;\n right_sib[c] = TSK_NULL;\n } else {\n right_sib[u] = c;\n left_sib[c] = u;\n right_sib[c] = TSK_NULL;\n }\n right_child[p] = c;\n num_children[p]++;\n}\n\nstatic inline void\ntsk_tree_insert_root(tsk_tree_t *self, tsk_id_t root, tsk_id_t *restrict parent)\n{\n tsk_tree_insert_branch(self, self->virtual_root, root, parent);\n parent[root] = TSK_NULL;\n}\n\nstatic inline void\ntsk_tree_remove_root(tsk_tree_t *self, tsk_id_t root, tsk_id_t *restrict parent)\n{\n tsk_tree_remove_branch(self, self->virtual_root, root, parent);\n}\n\nstatic void\ntsk_tree_remove_edge(\n tsk_tree_t *self, tsk_id_t p, tsk_id_t c, tsk_id_t TSK_UNUSED(edge_id))\n{\n tsk_id_t *restrict parent = self->parent;\n tsk_size_t *restrict num_samples = self->num_samples;\n tsk_size_t *restrict num_tracked_samples = self->num_tracked_samples;\n tsk_id_t *restrict edge = self->edge;\n const tsk_size_t root_threshold = self->root_threshold;\n tsk_id_t u;\n tsk_id_t path_end = TSK_NULL;\n bool path_end_was_root = false;\n\n#define POTENTIAL_ROOT(U) (num_samples[U] >= root_threshold)\n\n tsk_tree_remove_branch(self, p, c, parent);\n self->num_edges--;\n edge[c] = TSK_NULL;\n\n if (!(self->options & TSK_NO_SAMPLE_COUNTS)) {\n u = p;\n while (u != TSK_NULL) {\n path_end = u;\n path_end_was_root = POTENTIAL_ROOT(u);\n num_samples[u] -= num_samples[c];\n num_tracked_samples[u] -= num_tracked_samples[c];\n u = parent[u];\n }\n\n if (path_end_was_root && !POTENTIAL_ROOT(path_end)) {\n tsk_tree_remove_root(self, path_end, parent);\n }\n if (POTENTIAL_ROOT(c)) {\n tsk_tree_insert_root(self, c, parent);\n }\n }\n\n if (self->options & TSK_SAMPLE_LISTS) {\n tsk_tree_update_sample_lists(self, p, parent);\n }\n}\n\nstatic void\ntsk_tree_insert_edge(tsk_tree_t *self, tsk_id_t p, tsk_id_t c, tsk_id_t edge_id)\n{\n tsk_id_t *restrict parent = self->parent;\n tsk_size_t *restrict num_samples = self->num_samples;\n tsk_size_t *restrict num_tracked_samples = self->num_tracked_samples;\n tsk_id_t *restrict edge = self->edge;\n const tsk_size_t root_threshold = self->root_threshold;\n tsk_id_t u;\n tsk_id_t path_end = TSK_NULL;\n bool path_end_was_root = false;\n\n#define POTENTIAL_ROOT(U) (num_samples[U] >= root_threshold)\n\n if (!(self->options & TSK_NO_SAMPLE_COUNTS)) {\n u = p;\n while (u != TSK_NULL) {\n path_end = u;\n path_end_was_root = POTENTIAL_ROOT(u);\n num_samples[u] += num_samples[c];\n num_tracked_samples[u] += num_tracked_samples[c];\n u = parent[u];\n }\n\n if (POTENTIAL_ROOT(c)) {\n tsk_tree_remove_root(self, c, parent);\n }\n if (POTENTIAL_ROOT(path_end) && !path_end_was_root) {\n tsk_tree_insert_root(self, path_end, parent);\n }\n }\n\n tsk_tree_insert_branch(self, p, c, parent);\n self->num_edges++;\n edge[c] = edge_id;\n\n if (self->options & TSK_SAMPLE_LISTS) {\n tsk_tree_update_sample_lists(self, p, parent);\n }\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_first(tsk_tree_t *self)\n{\n int ret = TSK_TREE_OK;\n\n ret = tsk_tree_clear(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_tree_next(self);\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_last(tsk_tree_t *self)\n{\n int ret = TSK_TREE_OK;\n\n ret = tsk_tree_clear(self);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_tree_prev(self);\nout:\n return ret;\n}\n\nstatic void\ntsk_tree_update_index_and_interval(tsk_tree_t *self)\n{\n tsk_table_collection_t *tables = self->tree_sequence->tables;\n\n self->index = self->tree_pos.index;\n self->interval.left = self->tree_pos.interval.left;\n self->interval.right = self->tree_pos.interval.right;\n\n if (tables->sites.num_rows > 0) {\n self->sites = self->tree_sequence->tree_sites[self->index];\n self->sites_length = self->tree_sequence->tree_sites_length[self->index];\n }\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_next(tsk_tree_t *self)\n{\n int ret = 0;\n tsk_table_collection_t *tables = self->tree_sequence->tables;\n const tsk_id_t *restrict edge_parent = tables->edges.parent;\n const tsk_id_t *restrict edge_child = tables->edges.child;\n tsk_id_t j, e;\n tsk_tree_position_t tree_pos;\n bool valid;\n\n valid = tsk_tree_position_next(&self->tree_pos);\n tree_pos = self->tree_pos;\n\n if (valid) {\n for (j = tree_pos.out.start; j != tree_pos.out.stop; j++) {\n e = tree_pos.out.order[j];\n tsk_tree_remove_edge(self, edge_parent[e], edge_child[e], e);\n }\n\n for (j = tree_pos.in.start; j != tree_pos.in.stop; j++) {\n e = tree_pos.in.order[j];\n tsk_tree_insert_edge(self, edge_parent[e], edge_child[e], e);\n }\n ret = TSK_TREE_OK;\n tsk_tree_update_index_and_interval(self);\n } else {\n ret = tsk_tree_clear(self);\n }\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_prev(tsk_tree_t *self)\n{\n int ret = 0;\n tsk_table_collection_t *tables = self->tree_sequence->tables;\n const tsk_id_t *restrict edge_parent = tables->edges.parent;\n const tsk_id_t *restrict edge_child = tables->edges.child;\n tsk_id_t j, e;\n tsk_tree_position_t tree_pos;\n bool valid;\n\n valid = tsk_tree_position_prev(&self->tree_pos);\n tree_pos = self->tree_pos;\n\n if (valid) {\n for (j = tree_pos.out.start; j != tree_pos.out.stop; j--) {\n e = tree_pos.out.order[j];\n tsk_tree_remove_edge(self, edge_parent[e], edge_child[e], e);\n }\n\n for (j = tree_pos.in.start; j != tree_pos.in.stop; j--) {\n e = tree_pos.in.order[j];\n tsk_tree_insert_edge(self, edge_parent[e], edge_child[e], e);\n }\n ret = TSK_TREE_OK;\n tsk_tree_update_index_and_interval(self);\n } else {\n ret = tsk_tree_clear(self);\n }\n return ret;\n}\n\nstatic inline bool\ntsk_tree_position_in_interval(const tsk_tree_t *self, double x)\n{\n return self->interval.left <= x && x < self->interval.right;\n}\n\nstatic int\ntsk_tree_seek_from_null(tsk_tree_t *self, double x, tsk_flags_t TSK_UNUSED(options))\n{\n int ret = 0;\n tsk_table_collection_t *tables = self->tree_sequence->tables;\n const tsk_id_t *restrict edge_parent = tables->edges.parent;\n const tsk_id_t *restrict edge_child = tables->edges.child;\n const double *restrict edge_left = tables->edges.left;\n const double *restrict edge_right = tables->edges.right;\n double interval_left, interval_right;\n const double *restrict breakpoints = self->tree_sequence->breakpoints;\n const tsk_size_t num_trees = self->tree_sequence->num_trees;\n const double L = tsk_treeseq_get_sequence_length(self->tree_sequence);\n tsk_id_t j, e, index;\n tsk_tree_position_t tree_pos;\n\n index = (tsk_id_t) tsk_search_sorted(breakpoints, num_trees + 1, x);\n if (breakpoints[index] > x) {\n index--;\n }\n\n if (x <= L / 2.0) {\n ret = tsk_tree_position_seek_forward(&self->tree_pos, index);\n if (ret != 0) {\n goto out;\n }\n // Since we are seeking from null, there are no edges to remove\n tree_pos = self->tree_pos;\n interval_left = tree_pos.interval.left;\n for (j = tree_pos.in.start; j != tree_pos.in.stop; j++) {\n e = tree_pos.in.order[j];\n if (edge_left[e] <= interval_left && interval_left < edge_right[e]) {\n tsk_tree_insert_edge(self, edge_parent[e], edge_child[e], e);\n }\n }\n } else {\n ret = tsk_tree_position_seek_backward(&self->tree_pos, index);\n if (ret != 0) {\n goto out;\n }\n tree_pos = self->tree_pos;\n interval_right = tree_pos.interval.right;\n for (j = tree_pos.in.start; j != tree_pos.in.stop; j--) {\n e = tree_pos.in.order[j];\n if (edge_right[e] >= interval_right && interval_right > edge_left[e]) {\n tsk_tree_insert_edge(self, edge_parent[e], edge_child[e], e);\n }\n }\n }\n tsk_tree_update_index_and_interval(self);\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_tree_seek_forward(tsk_tree_t *self, tsk_id_t index)\n{\n int ret = 0;\n tsk_table_collection_t *tables = self->tree_sequence->tables;\n const tsk_id_t *restrict edge_parent = tables->edges.parent;\n const tsk_id_t *restrict edge_child = tables->edges.child;\n const double *restrict edge_left = tables->edges.left;\n const double *restrict edge_right = tables->edges.right;\n double interval_left, e_left;\n const double old_right = self->interval.right;\n tsk_id_t j, e;\n tsk_tree_position_t tree_pos;\n\n ret = tsk_tree_position_seek_forward(&self->tree_pos, index);\n if (ret != 0) {\n goto out;\n }\n tree_pos = self->tree_pos;\n interval_left = tree_pos.interval.left;\n\n for (j = tree_pos.out.start; j != tree_pos.out.stop; j++) {\n e = tree_pos.out.order[j];\n e_left = edge_left[e];\n if (e_left < old_right) {\n tsk_bug_assert(edge_parent[e] != TSK_NULL);\n tsk_tree_remove_edge(self, edge_parent[e], edge_child[e], e);\n }\n tsk_bug_assert(e_left < interval_left);\n }\n\n for (j = tree_pos.in.start; j != tree_pos.in.stop; j++) {\n e = tree_pos.in.order[j];\n if (edge_left[e] <= interval_left && interval_left < edge_right[e]) {\n tsk_tree_insert_edge(self, edge_parent[e], edge_child[e], e);\n }\n }\n tsk_tree_update_index_and_interval(self);\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_tree_seek_backward(tsk_tree_t *self, tsk_id_t index)\n{\n int ret = 0;\n tsk_table_collection_t *tables = self->tree_sequence->tables;\n const tsk_id_t *restrict edge_parent = tables->edges.parent;\n const tsk_id_t *restrict edge_child = tables->edges.child;\n const double *restrict edge_left = tables->edges.left;\n const double *restrict edge_right = tables->edges.right;\n double interval_right, e_right;\n const double old_right = self->interval.right;\n tsk_id_t j, e;\n tsk_tree_position_t tree_pos;\n\n ret = tsk_tree_position_seek_backward(&self->tree_pos, index);\n if (ret != 0) {\n goto out;\n }\n tree_pos = self->tree_pos;\n interval_right = tree_pos.interval.right;\n\n for (j = tree_pos.out.start; j != tree_pos.out.stop; j--) {\n e = tree_pos.out.order[j];\n e_right = edge_right[e];\n if (e_right >= old_right) {\n tsk_bug_assert(edge_parent[e] != TSK_NULL);\n tsk_tree_remove_edge(self, edge_parent[e], edge_child[e], e);\n }\n tsk_bug_assert(e_right > interval_right);\n }\n\n for (j = tree_pos.in.start; j != tree_pos.in.stop; j--) {\n e = tree_pos.in.order[j];\n if (edge_right[e] >= interval_right && interval_right > edge_left[e]) {\n tsk_tree_insert_edge(self, edge_parent[e], edge_child[e], e);\n }\n }\n tsk_tree_update_index_and_interval(self);\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_seek_index(tsk_tree_t *self, tsk_id_t tree, tsk_flags_t options)\n{\n int ret = 0;\n double x;\n\n if (tree < 0 || tree >= (tsk_id_t) self->tree_sequence->num_trees) {\n ret = tsk_trace_error(TSK_ERR_SEEK_OUT_OF_BOUNDS);\n goto out;\n }\n x = self->tree_sequence->breakpoints[tree];\n ret = tsk_tree_seek(self, x, options);\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_tree_seek_linear(tsk_tree_t *self, double x)\n{\n const double L = tsk_treeseq_get_sequence_length(self->tree_sequence);\n const double t_l = self->interval.left;\n const double t_r = self->interval.right;\n int ret = 0;\n double distance_left, distance_right;\n\n if (x < t_l) {\n /* |-----|-----|========|---------| */\n /* 0 x t_l t_r L */\n distance_left = t_l - x;\n distance_right = L - t_r + x;\n } else {\n /* |------|========|------|-------| */\n /* 0 t_l t_r x L */\n distance_right = x - t_r;\n distance_left = t_l + L - x;\n }\n if (distance_right <= distance_left) {\n while (!tsk_tree_position_in_interval(self, x)) {\n ret = tsk_tree_next(self);\n if (ret < 0) {\n goto out;\n }\n }\n } else {\n while (!tsk_tree_position_in_interval(self, x)) {\n ret = tsk_tree_prev(self);\n if (ret < 0) {\n goto out;\n }\n }\n }\n ret = 0;\nout:\n return ret;\n}\n\nstatic int TSK_WARN_UNUSED\ntsk_tree_seek_skip(tsk_tree_t *self, double x)\n{\n const double t_l = self->interval.left;\n int ret = 0;\n tsk_id_t index;\n const tsk_size_t num_trees = self->tree_sequence->num_trees;\n const double *restrict breakpoints = self->tree_sequence->breakpoints;\n\n index = (tsk_id_t) tsk_search_sorted(breakpoints, num_trees + 1, x);\n if (breakpoints[index] > x) {\n index--;\n }\n\n if (x < t_l) {\n ret = tsk_tree_seek_backward(self, index);\n } else {\n ret = tsk_tree_seek_forward(self, index);\n }\n tsk_bug_assert(tsk_tree_position_in_interval(self, x));\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_seek(tsk_tree_t *self, double x, tsk_flags_t options)\n{\n int ret = 0;\n const double L = tsk_treeseq_get_sequence_length(self->tree_sequence);\n\n if (x < 0 || x >= L) {\n ret = tsk_trace_error(TSK_ERR_SEEK_OUT_OF_BOUNDS);\n goto out;\n }\n\n if (self->index == -1) {\n ret = tsk_tree_seek_from_null(self, x, options);\n } else {\n if (options & TSK_SEEK_SKIP) {\n ret = tsk_tree_seek_skip(self, x);\n } else {\n ret = tsk_tree_seek_linear(self, x);\n }\n }\n\nout:\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_tree_clear(tsk_tree_t *self)\n{\n int ret = 0;\n tsk_size_t j;\n tsk_id_t u;\n const tsk_size_t N = self->num_nodes + 1;\n const tsk_size_t num_samples = self->tree_sequence->num_samples;\n const bool sample_counts = !(self->options & TSK_NO_SAMPLE_COUNTS);\n const bool sample_lists = !!(self->options & TSK_SAMPLE_LISTS);\n const tsk_flags_t *flags = self->tree_sequence->tables->nodes.flags;\n\n self->interval.left = 0;\n self->interval.right = 0;\n self->num_edges = 0;\n self->index = -1;\n tsk_tree_position_set_null(&self->tree_pos);\n /* TODO we should profile this method to see if just doing a single loop over\n * the nodes would be more efficient than multiple memsets.\n */\n tsk_memset(self->parent, 0xff, N * sizeof(*self->parent));\n tsk_memset(self->left_child, 0xff, N * sizeof(*self->left_child));\n tsk_memset(self->right_child, 0xff, N * sizeof(*self->right_child));\n tsk_memset(self->left_sib, 0xff, N * sizeof(*self->left_sib));\n tsk_memset(self->right_sib, 0xff, N * sizeof(*self->right_sib));\n tsk_memset(self->num_children, 0, N * sizeof(*self->num_children));\n tsk_memset(self->edge, 0xff, N * sizeof(*self->edge));\n\n if (sample_counts) {\n tsk_memset(self->num_samples, 0, N * sizeof(*self->num_samples));\n /* We can't reset the tracked samples via memset because we don't\n * know where the tracked samples are.\n */\n for (j = 0; j < self->num_nodes; j++) {\n if (!(flags[j] & TSK_NODE_IS_SAMPLE)) {\n self->num_tracked_samples[j] = 0;\n }\n }\n /* The total tracked_samples gets set in set_tracked_samples */\n self->num_samples[self->virtual_root] = num_samples;\n }\n if (sample_lists) {\n tsk_memset(self->left_sample, 0xff, N * sizeof(tsk_id_t));\n tsk_memset(self->right_sample, 0xff, N * sizeof(tsk_id_t));\n tsk_memset(self->next_sample, 0xff, num_samples * sizeof(tsk_id_t));\n }\n /* Set the sample attributes */\n for (j = 0; j < num_samples; j++) {\n u = self->samples[j];\n if (sample_counts) {\n self->num_samples[u] = 1;\n }\n if (sample_lists) {\n /* We are mapping to *indexes* into the list of samples here */\n self->left_sample[u] = (tsk_id_t) j;\n self->right_sample[u] = (tsk_id_t) j;\n }\n }\n if (sample_counts && self->root_threshold == 1 && num_samples > 0) {\n for (j = 0; j < num_samples; j++) {\n /* Set initial roots */\n if (self->root_threshold == 1) {\n tsk_tree_insert_root(self, self->samples[j], self->parent);\n }\n }\n }\n return ret;\n}\n\ntsk_size_t\ntsk_tree_get_size_bound(const tsk_tree_t *self)\n{\n tsk_size_t bound = 0;\n\n if (self->tree_sequence != NULL) {\n /* This is a safe upper bound which can be computed cheaply.\n * We have at most n roots and each edge adds at most one new\n * node to the tree. We also allow space for the virtual root,\n * to simplify client code.\n *\n * In the common case of a binary tree with a single root, we have\n * 2n - 1 nodes in total, and 2n - 2 edges. Therefore, we return\n * 3n - 1, which is an over-estimate of 1/2 and we allocate\n * 1.5 times as much memory as we need.\n *\n * Since tracking the exact number of nodes in the tree would require\n * storing the number of nodes beneath every node and complicate\n * the tree transition method, this seems like a good compromise\n * and will result in less memory usage overall in nearly all cases.\n */\n bound = 1 + self->tree_sequence->num_samples + self->num_edges;\n }\n return bound;\n}\n\n/* Traversal orders */\nstatic tsk_id_t *\ntsk_tree_alloc_node_stack(const tsk_tree_t *self)\n{\n return tsk_malloc(tsk_tree_get_size_bound(self) * sizeof(tsk_id_t));\n}\n\nint\ntsk_tree_preorder(const tsk_tree_t *self, tsk_id_t *nodes, tsk_size_t *num_nodes_ret)\n{\n return tsk_tree_preorder_from(self, -1, nodes, num_nodes_ret);\n}\n\nint\ntsk_tree_preorder_from(\n const tsk_tree_t *self, tsk_id_t root, tsk_id_t *nodes, tsk_size_t *num_nodes_ret)\n{\n int ret = 0;\n const tsk_id_t *restrict right_child = self->right_child;\n const tsk_id_t *restrict left_sib = self->left_sib;\n tsk_id_t *stack = tsk_tree_alloc_node_stack(self);\n tsk_size_t num_nodes = 0;\n tsk_id_t u, v;\n int stack_top;\n\n if (stack == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n if ((root == -1 || root == self->virtual_root)\n && !tsk_tree_has_sample_counts(self)) {\n ret = tsk_trace_error(TSK_ERR_UNSUPPORTED_OPERATION);\n goto out;\n }\n if (root == -1) {\n stack_top = -1;\n for (u = right_child[self->virtual_root]; u != TSK_NULL; u = left_sib[u]) {\n stack_top++;\n stack[stack_top] = u;\n }\n } else {\n ret = tsk_tree_check_node(self, root);\n if (ret != 0) {\n goto out;\n }\n stack_top = 0;\n stack[stack_top] = root;\n }\n\n while (stack_top >= 0) {\n u = stack[stack_top];\n stack_top--;\n nodes[num_nodes] = u;\n num_nodes++;\n for (v = right_child[u]; v != TSK_NULL; v = left_sib[v]) {\n stack_top++;\n stack[stack_top] = v;\n }\n }\n *num_nodes_ret = num_nodes;\nout:\n tsk_safe_free(stack);\n return ret;\n}\n\n/* We could implement this using the preorder function, but since it's\n * going to be performance critical we want to avoid the overhead\n * of mallocing the intermediate node list (which will be bigger than\n * the number of samples). */\nint\ntsk_tree_preorder_samples_from(\n const tsk_tree_t *self, tsk_id_t root, tsk_id_t *nodes, tsk_size_t *num_nodes_ret)\n{\n int ret = 0;\n const tsk_id_t *restrict right_child = self->right_child;\n const tsk_id_t *restrict left_sib = self->left_sib;\n const tsk_flags_t *restrict flags = self->tree_sequence->tables->nodes.flags;\n tsk_id_t *stack = tsk_tree_alloc_node_stack(self);\n tsk_size_t num_nodes = 0;\n tsk_id_t u, v;\n int stack_top;\n\n if (stack == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n /* We could push the virtual_root onto the stack directly to simplify\n * the code a little, but then we'd have to check put an extra check\n * when looking up the flags array (which isn't defined for virtual_root).\n */\n if (root == -1 || root == self->virtual_root) {\n if (!tsk_tree_has_sample_counts(self)) {\n ret = tsk_trace_error(TSK_ERR_UNSUPPORTED_OPERATION);\n goto out;\n }\n stack_top = -1;\n for (u = right_child[self->virtual_root]; u != TSK_NULL; u = left_sib[u]) {\n stack_top++;\n stack[stack_top] = u;\n }\n } else {\n ret = tsk_tree_check_node(self, root);\n if (ret != 0) {\n goto out;\n }\n stack_top = 0;\n stack[stack_top] = root;\n }\n\n while (stack_top >= 0) {\n u = stack[stack_top];\n stack_top--;\n if (flags[u] & TSK_NODE_IS_SAMPLE) {\n nodes[num_nodes] = u;\n num_nodes++;\n }\n for (v = right_child[u]; v != TSK_NULL; v = left_sib[v]) {\n stack_top++;\n stack[stack_top] = v;\n }\n }\n *num_nodes_ret = num_nodes;\nout:\n tsk_safe_free(stack);\n return ret;\n}\n\nint\ntsk_tree_postorder(const tsk_tree_t *self, tsk_id_t *nodes, tsk_size_t *num_nodes_ret)\n{\n return tsk_tree_postorder_from(self, -1, nodes, num_nodes_ret);\n}\nint\ntsk_tree_postorder_from(\n const tsk_tree_t *self, tsk_id_t root, tsk_id_t *nodes, tsk_size_t *num_nodes_ret)\n{\n int ret = 0;\n const tsk_id_t *restrict right_child = self->right_child;\n const tsk_id_t *restrict left_sib = self->left_sib;\n const tsk_id_t *restrict parent = self->parent;\n tsk_id_t *stack = tsk_tree_alloc_node_stack(self);\n tsk_size_t num_nodes = 0;\n tsk_id_t u, v, postorder_parent;\n int stack_top;\n bool is_virtual_root = root == self->virtual_root;\n\n if (stack == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n if (root == -1 || is_virtual_root) {\n if (!tsk_tree_has_sample_counts(self)) {\n ret = tsk_trace_error(TSK_ERR_UNSUPPORTED_OPERATION);\n goto out;\n }\n stack_top = -1;\n for (u = right_child[self->virtual_root]; u != TSK_NULL; u = left_sib[u]) {\n stack_top++;\n stack[stack_top] = u;\n }\n } else {\n ret = tsk_tree_check_node(self, root);\n if (ret != 0) {\n goto out;\n }\n stack_top = 0;\n stack[stack_top] = root;\n }\n\n postorder_parent = TSK_NULL;\n while (stack_top >= 0) {\n u = stack[stack_top];\n if (right_child[u] != TSK_NULL && u != postorder_parent) {\n for (v = right_child[u]; v != TSK_NULL; v = left_sib[v]) {\n stack_top++;\n stack[stack_top] = v;\n }\n } else {\n stack_top--;\n postorder_parent = parent[u];\n nodes[num_nodes] = u;\n num_nodes++;\n }\n }\n if (is_virtual_root) {\n nodes[num_nodes] = root;\n num_nodes++;\n }\n *num_nodes_ret = num_nodes;\nout:\n tsk_safe_free(stack);\n return ret;\n}\n\n/* Balance/imbalance metrics */\n\n/* Result is a tsk_size_t value here because we could imagine the total\n * depth overflowing a 32bit integer for a large tree. */\nint\ntsk_tree_sackin_index(const tsk_tree_t *self, tsk_size_t *result)\n{\n /* Keep the size of the stack elements to 8 bytes in total in the\n * standard case. A tsk_id_t depth value is always safe, since\n * depth counts the number of nodes encountered on a path.\n */\n struct stack_elem {\n tsk_id_t node;\n tsk_id_t depth;\n };\n int ret = 0;\n const tsk_id_t *restrict right_child = self->right_child;\n const tsk_id_t *restrict left_sib = self->left_sib;\n struct stack_elem *stack\n = tsk_malloc(tsk_tree_get_size_bound(self) * sizeof(*stack));\n int stack_top;\n tsk_size_t total_depth;\n tsk_id_t u;\n struct stack_elem s = { .node = TSK_NULL, .depth = 0 };\n\n if (stack == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n stack_top = -1;\n for (u = right_child[self->virtual_root]; u != TSK_NULL; u = left_sib[u]) {\n stack_top++;\n s.node = u;\n stack[stack_top] = s;\n }\n total_depth = 0;\n while (stack_top >= 0) {\n s = stack[stack_top];\n stack_top--;\n u = right_child[s.node];\n if (u == TSK_NULL) {\n total_depth += (tsk_size_t) s.depth;\n } else {\n s.depth++;\n while (u != TSK_NULL) {\n stack_top++;\n s.node = u;\n stack[stack_top] = s;\n u = left_sib[u];\n }\n }\n }\n *result = total_depth;\nout:\n tsk_safe_free(stack);\n return ret;\n}\n\nint\ntsk_tree_colless_index(const tsk_tree_t *self, tsk_size_t *result)\n{\n int ret = 0;\n const tsk_id_t *restrict right_child = self->right_child;\n const tsk_id_t *restrict left_sib = self->left_sib;\n tsk_id_t *nodes = tsk_malloc(tsk_tree_get_size_bound(self) * sizeof(*nodes));\n tsk_id_t *num_leaves = tsk_calloc(self->num_nodes, sizeof(*num_leaves));\n tsk_size_t j, num_nodes, total;\n tsk_id_t num_children, u, v;\n\n if (nodes == NULL || num_leaves == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n if (tsk_tree_get_num_roots(self) != 1) {\n ret = tsk_trace_error(TSK_ERR_UNDEFINED_MULTIROOT);\n goto out;\n }\n ret = tsk_tree_postorder(self, nodes, &num_nodes);\n if (ret != 0) {\n goto out;\n }\n\n total = 0;\n for (j = 0; j < num_nodes; j++) {\n u = nodes[j];\n /* Cheaper to compute this on the fly than to access the num_children array.\n * since we're already iterating over the children. */\n num_children = 0;\n for (v = right_child[u]; v != TSK_NULL; v = left_sib[v]) {\n num_children++;\n num_leaves[u] += num_leaves[v];\n }\n if (num_children == 0) {\n num_leaves[u] = 1;\n } else if (num_children == 2) {\n v = right_child[u];\n total += (tsk_size_t) llabs(num_leaves[v] - num_leaves[left_sib[v]]);\n } else {\n ret = tsk_trace_error(TSK_ERR_UNDEFINED_NONBINARY);\n goto out;\n }\n }\n *result = total;\nout:\n tsk_safe_free(nodes);\n tsk_safe_free(num_leaves);\n return ret;\n}\n\nint\ntsk_tree_b1_index(const tsk_tree_t *self, double *result)\n{\n int ret = 0;\n const tsk_id_t *restrict parent = self->parent;\n const tsk_id_t *restrict right_child = self->right_child;\n const tsk_id_t *restrict left_sib = self->left_sib;\n tsk_id_t *nodes = tsk_malloc(tsk_tree_get_size_bound(self) * sizeof(*nodes));\n tsk_size_t *max_path_length = tsk_calloc(self->num_nodes, sizeof(*max_path_length));\n tsk_size_t j, num_nodes, mpl;\n double total = 0.0;\n tsk_id_t u, v;\n\n if (nodes == NULL || max_path_length == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n ret = tsk_tree_postorder(self, nodes, &num_nodes);\n if (ret != 0) {\n goto out;\n }\n\n for (j = 0; j < num_nodes; j++) {\n u = nodes[j];\n if (parent[u] != TSK_NULL && right_child[u] != TSK_NULL) {\n mpl = 0;\n for (v = right_child[u]; v != TSK_NULL; v = left_sib[v]) {\n mpl = TSK_MAX(mpl, max_path_length[v]);\n }\n max_path_length[u] = mpl + 1;\n total += 1 / (double) max_path_length[u];\n }\n }\n *result = total;\nout:\n tsk_safe_free(nodes);\n tsk_safe_free(max_path_length);\n return ret;\n}\n\nstatic double\ngeneral_log(double x, double base)\n{\n return log(x) / log(base);\n}\n\nint\ntsk_tree_b2_index(const tsk_tree_t *self, double base, double *result)\n{\n struct stack_elem {\n tsk_id_t node;\n double path_product;\n };\n int ret = 0;\n const tsk_id_t *restrict right_child = self->right_child;\n const tsk_id_t *restrict left_sib = self->left_sib;\n struct stack_elem *stack\n = tsk_malloc(tsk_tree_get_size_bound(self) * sizeof(*stack));\n int stack_top;\n double total_proba = 0;\n double num_children;\n tsk_id_t u;\n struct stack_elem s = { .node = TSK_NULL, .path_product = 1 };\n\n if (stack == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n if (tsk_tree_get_num_roots(self) != 1) {\n ret = tsk_trace_error(TSK_ERR_UNDEFINED_MULTIROOT);\n goto out;\n }\n\n stack_top = 0;\n s.node = tsk_tree_get_left_root(self);\n stack[stack_top] = s;\n\n while (stack_top >= 0) {\n s = stack[stack_top];\n stack_top--;\n u = right_child[s.node];\n if (u == TSK_NULL) {\n total_proba -= s.path_product * general_log(s.path_product, base);\n } else {\n num_children = 0;\n for (; u != TSK_NULL; u = left_sib[u]) {\n num_children++;\n }\n s.path_product *= 1 / num_children;\n for (u = right_child[s.node]; u != TSK_NULL; u = left_sib[u]) {\n stack_top++;\n s.node = u;\n stack[stack_top] = s;\n }\n }\n }\n *result = total_proba;\nout:\n tsk_safe_free(stack);\n return ret;\n}\n\nint\ntsk_tree_num_lineages(const tsk_tree_t *self, double t, tsk_size_t *result)\n{\n int ret = 0;\n const tsk_id_t *restrict right_child = self->right_child;\n const tsk_id_t *restrict left_sib = self->left_sib;\n const double *restrict time = self->tree_sequence->tables->nodes.time;\n tsk_id_t *stack = tsk_tree_alloc_node_stack(self);\n tsk_size_t num_lineages = 0;\n int stack_top;\n tsk_id_t u, v;\n double child_time, parent_time;\n\n if (stack == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n if (!tsk_isfinite(t)) {\n ret = tsk_trace_error(TSK_ERR_TIME_NONFINITE);\n goto out;\n }\n /* Push the roots onto the stack */\n stack_top = -1;\n for (u = right_child[self->virtual_root]; u != TSK_NULL; u = left_sib[u]) {\n stack_top++;\n stack[stack_top] = u;\n }\n\n while (stack_top >= 0) {\n u = stack[stack_top];\n parent_time = time[u];\n stack_top--;\n for (v = right_child[u]; v != TSK_NULL; v = left_sib[v]) {\n child_time = time[v];\n /* Only traverse down the tree as far as we need to */\n if (child_time > t) {\n stack_top++;\n stack[stack_top] = v;\n } else if (t < parent_time) {\n num_lineages++;\n }\n }\n }\n *result = num_lineages;\nout:\n tsk_safe_free(stack);\n return ret;\n}\n\n/* Parsimony methods */\n\nstatic inline uint64_t\nset_bit(uint64_t value, int32_t bit)\n{\n return value | (1ULL << bit);\n}\n\nstatic inline bool\nbit_is_set(uint64_t value, int32_t bit)\n{\n return (value & (1ULL << bit)) != 0;\n}\n\nstatic inline int8_t\nget_smallest_set_bit(uint64_t v)\n{\n /* This is an inefficient implementation, there are several better\n * approaches. On GCC we can use\n * return (uint8_t) (__builtin_ffsll((long long) v) - 1);\n */\n uint64_t t = 1;\n int8_t r = 0;\n\n assert(v != 0);\n while ((v & t) == 0) {\n t <<= 1;\n r++;\n }\n return r;\n}\n\n#define HARTIGAN_MAX_ALLELES 64\n\n/* This interface is experimental. In the future, we should provide the option to\n * use a general cost matrix, in which case we'll use the Sankoff algorithm. For\n * now this is unused.\n *\n * We should also vectorise the function so that several sites can be processed\n * at once.\n *\n * The algorithm used here is Hartigan parsimony, \"Minimum Mutation Fits to a\n * Given Tree\", Biometrics 1973.\n */\nint TSK_WARN_UNUSED\ntsk_tree_map_mutations(tsk_tree_t *self, int32_t *genotypes,\n double *TSK_UNUSED(cost_matrix), tsk_flags_t options, int32_t *r_ancestral_state,\n tsk_size_t *r_num_transitions, tsk_state_transition_t **r_transitions)\n{\n int ret = 0;\n struct stack_elem {\n tsk_id_t node;\n tsk_id_t transition_parent;\n int32_t state;\n };\n const tsk_size_t num_samples = self->tree_sequence->num_samples;\n const tsk_id_t *restrict left_child = self->left_child;\n const tsk_id_t *restrict right_sib = self->right_sib;\n const tsk_size_t N = tsk_treeseq_get_num_nodes(self->tree_sequence);\n const tsk_flags_t *restrict node_flags = self->tree_sequence->tables->nodes.flags;\n tsk_id_t *nodes = tsk_malloc(tsk_tree_get_size_bound(self) * sizeof(*nodes));\n /* Note: to use less memory here and to improve cache performance we should\n * probably change to allocating exactly the number of nodes returned by\n * a preorder traversal, and then lay the memory out in this order. So, we'd\n * need a map from node ID to its index in the preorder traversal, but this\n * is trivial to compute. Probably doesn't matter so much at the moment\n * when we're doing a single site, but it would make a big difference if\n * we were vectorising over lots of sites. */\n uint64_t *restrict optimal_set = tsk_calloc(N + 1, sizeof(*optimal_set));\n struct stack_elem *restrict preorder_stack\n = tsk_malloc(tsk_tree_get_size_bound(self) * sizeof(*preorder_stack));\n tsk_id_t u, v;\n /* The largest possible number of transitions is one over every sample */\n tsk_state_transition_t *transitions = tsk_malloc(num_samples * sizeof(*transitions));\n int32_t allele, ancestral_state;\n int stack_top;\n struct stack_elem s;\n tsk_size_t j, num_transitions, max_allele_count, num_nodes;\n tsk_size_t allele_count[HARTIGAN_MAX_ALLELES];\n tsk_size_t non_missing = 0;\n int32_t num_alleles = 0;\n\n if (optimal_set == NULL || preorder_stack == NULL || transitions == NULL\n || nodes == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n for (j = 0; j < num_samples; j++) {\n if (genotypes[j] >= HARTIGAN_MAX_ALLELES || genotypes[j] < TSK_MISSING_DATA) {\n ret = tsk_trace_error(TSK_ERR_BAD_GENOTYPE);\n goto out;\n }\n u = self->tree_sequence->samples[j];\n if (genotypes[j] == TSK_MISSING_DATA) {\n /* All bits set */\n optimal_set[u] = UINT64_MAX;\n } else {\n optimal_set[u] = set_bit(optimal_set[u], genotypes[j]);\n num_alleles = TSK_MAX(genotypes[j], num_alleles);\n non_missing++;\n }\n }\n\n if (non_missing == 0) {\n ret = tsk_trace_error(TSK_ERR_GENOTYPES_ALL_MISSING);\n goto out;\n }\n num_alleles++;\n\n ancestral_state = 0; /* keep compiler happy */\n if (options & TSK_MM_FIXED_ANCESTRAL_STATE) {\n ancestral_state = *r_ancestral_state;\n if ((ancestral_state < 0) || (ancestral_state >= HARTIGAN_MAX_ALLELES)) {\n ret = tsk_trace_error(TSK_ERR_BAD_ANCESTRAL_STATE);\n goto out;\n } else if (ancestral_state >= num_alleles) {\n num_alleles = (int32_t) (ancestral_state + 1);\n }\n }\n\n ret = tsk_tree_postorder_from(self, self->virtual_root, nodes, &num_nodes);\n if (ret != 0) {\n goto out;\n }\n for (j = 0; j < num_nodes; j++) {\n u = nodes[j];\n tsk_memset(allele_count, 0, ((size_t) num_alleles) * sizeof(*allele_count));\n for (v = left_child[u]; v != TSK_NULL; v = right_sib[v]) {\n for (allele = 0; allele < num_alleles; allele++) {\n allele_count[allele] += bit_is_set(optimal_set[v], allele);\n }\n }\n /* the virtual root has no flags defined */\n if (u == (tsk_id_t) N || !(node_flags[u] & TSK_NODE_IS_SAMPLE)) {\n max_allele_count = 0;\n for (allele = 0; allele < num_alleles; allele++) {\n max_allele_count = TSK_MAX(max_allele_count, allele_count[allele]);\n }\n for (allele = 0; allele < num_alleles; allele++) {\n if (allele_count[allele] == max_allele_count) {\n optimal_set[u] = set_bit(optimal_set[u], allele);\n }\n }\n }\n }\n if (!(options & TSK_MM_FIXED_ANCESTRAL_STATE)) {\n ancestral_state = get_smallest_set_bit(optimal_set[self->virtual_root]);\n } else {\n optimal_set[self->virtual_root] = UINT64_MAX;\n }\n\n num_transitions = 0;\n\n /* Do a preorder traversal */\n preorder_stack[0].node = self->virtual_root;\n preorder_stack[0].state = ancestral_state;\n preorder_stack[0].transition_parent = TSK_NULL;\n stack_top = 0;\n while (stack_top >= 0) {\n s = preorder_stack[stack_top];\n stack_top--;\n\n if (!bit_is_set(optimal_set[s.node], s.state)) {\n s.state = get_smallest_set_bit(optimal_set[s.node]);\n transitions[num_transitions].node = s.node;\n transitions[num_transitions].parent = s.transition_parent;\n transitions[num_transitions].state = s.state;\n s.transition_parent = (tsk_id_t) num_transitions;\n num_transitions++;\n }\n for (v = left_child[s.node]; v != TSK_NULL; v = right_sib[v]) {\n stack_top++;\n s.node = v;\n preorder_stack[stack_top] = s;\n }\n }\n\n *r_transitions = transitions;\n *r_num_transitions = num_transitions;\n *r_ancestral_state = ancestral_state;\n transitions = NULL;\nout:\n tsk_safe_free(transitions);\n /* Cannot safe_free because of 'restrict' */\n if (optimal_set != NULL) {\n free(optimal_set);\n }\n if (preorder_stack != NULL) {\n free(preorder_stack);\n }\n if (nodes != NULL) {\n free(nodes);\n }\n return ret;\n}\n\n/* ======================================================== *\n * KC Distance\n * ======================================================== */\n\ntypedef struct {\n tsk_size_t *m;\n double *M;\n tsk_id_t n;\n tsk_id_t N;\n} kc_vectors;\n\nstatic int\nkc_vectors_alloc(kc_vectors *self, tsk_id_t n)\n{\n int ret = 0;\n\n self->n = n;\n self->N = (n * (n - 1)) / 2;\n self->m = tsk_calloc((size_t) (self->N + self->n), sizeof(*self->m));\n self->M = tsk_calloc((size_t) (self->N + self->n), sizeof(*self->M));\n if (self->m == NULL || self->M == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\nout:\n return ret;\n}\n\nstatic void\nkc_vectors_free(kc_vectors *self)\n{\n tsk_safe_free(self->m);\n tsk_safe_free(self->M);\n}\n\nstatic inline void\nupdate_kc_vectors_single_sample(\n const tsk_treeseq_t *ts, kc_vectors *kc_vecs, tsk_id_t u, double time)\n{\n const tsk_id_t *sample_index_map = ts->sample_index_map;\n tsk_id_t u_index = sample_index_map[u];\n\n kc_vecs->m[kc_vecs->N + u_index] = 1;\n kc_vecs->M[kc_vecs->N + u_index] = time;\n}\n\nstatic inline void\nupdate_kc_vectors_all_pairs(const tsk_tree_t *tree, kc_vectors *kc_vecs, tsk_id_t u,\n tsk_id_t v, tsk_size_t depth, double time)\n{\n tsk_id_t sample1_index, sample2_index, n1, n2, tmp, pair_index;\n const tsk_id_t *restrict left_sample = tree->left_sample;\n const tsk_id_t *restrict right_sample = tree->right_sample;\n const tsk_id_t *restrict next_sample = tree->next_sample;\n tsk_size_t *restrict kc_m = kc_vecs->m;\n double *restrict kc_M = kc_vecs->M;\n\n sample1_index = left_sample[u];\n while (sample1_index != TSK_NULL) {\n sample2_index = left_sample[v];\n while (sample2_index != TSK_NULL) {\n n1 = sample1_index;\n n2 = sample2_index;\n if (n1 > n2) {\n tmp = n1;\n n1 = n2;\n n2 = tmp;\n }\n\n /* We spend ~40% of our time here because these accesses\n * are not in order and gets very poor cache behavior */\n pair_index = n2 - n1 - 1 + (-1 * n1 * (n1 - 2 * kc_vecs->n + 1)) / 2;\n kc_m[pair_index] = depth;\n kc_M[pair_index] = time;\n\n if (sample2_index == right_sample[v]) {\n break;\n }\n sample2_index = next_sample[sample2_index];\n }\n if (sample1_index == right_sample[u]) {\n break;\n }\n sample1_index = next_sample[sample1_index];\n }\n}\n\nstruct kc_stack_elmt {\n tsk_id_t node;\n tsk_size_t depth;\n};\n\nstatic int\nfill_kc_vectors(const tsk_tree_t *t, kc_vectors *kc_vecs)\n{\n int stack_top;\n tsk_size_t depth;\n double time;\n const double *times;\n struct kc_stack_elmt *stack;\n tsk_id_t root, u, c1, c2;\n int ret = 0;\n const tsk_treeseq_t *ts = t->tree_sequence;\n\n stack = tsk_malloc(tsk_tree_get_size_bound(t) * sizeof(*stack));\n if (stack == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n times = t->tree_sequence->tables->nodes.time;\n\n for (root = tsk_tree_get_left_root(t); root != TSK_NULL; root = t->right_sib[root]) {\n stack_top = 0;\n stack[stack_top].node = root;\n stack[stack_top].depth = 0;\n while (stack_top >= 0) {\n u = stack[stack_top].node;\n depth = stack[stack_top].depth;\n stack_top--;\n\n if (tsk_tree_is_sample(t, u)) {\n time = tsk_tree_get_branch_length_unsafe(t, u);\n update_kc_vectors_single_sample(ts, kc_vecs, u, time);\n }\n\n /* Don't bother going deeper if there are no samples under this node */\n if (t->left_sample[u] != TSK_NULL) {\n for (c1 = t->left_child[u]; c1 != TSK_NULL; c1 = t->right_sib[c1]) {\n stack_top++;\n stack[stack_top].node = c1;\n stack[stack_top].depth = depth + 1;\n\n for (c2 = t->right_sib[c1]; c2 != TSK_NULL; c2 = t->right_sib[c2]) {\n time = times[root] - times[u];\n update_kc_vectors_all_pairs(t, kc_vecs, c1, c2, depth, time);\n }\n }\n }\n }\n }\n\nout:\n tsk_safe_free(stack);\n return ret;\n}\n\nstatic double\nnorm_kc_vectors(kc_vectors *self, kc_vectors *other, double lambda)\n{\n double vT1, vT2, distance_sum;\n tsk_id_t i;\n\n distance_sum = 0;\n for (i = 0; i < self->n + self->N; i++) {\n vT1 = ((double) self->m[i] * (1 - lambda)) + (lambda * self->M[i]);\n vT2 = ((double) other->m[i] * (1 - lambda)) + (lambda * other->M[i]);\n distance_sum += (vT1 - vT2) * (vT1 - vT2);\n }\n\n return sqrt(distance_sum);\n}\n\nstatic int\ncheck_kc_distance_tree_inputs(const tsk_tree_t *self)\n{\n tsk_id_t u, num_nodes, left_child;\n int ret = 0;\n\n if (tsk_tree_get_num_roots(self) != 1) {\n ret = tsk_trace_error(TSK_ERR_MULTIPLE_ROOTS);\n goto out;\n }\n if (!tsk_tree_has_sample_lists(self)) {\n ret = tsk_trace_error(TSK_ERR_NO_SAMPLE_LISTS);\n goto out;\n }\n\n num_nodes = (tsk_id_t) tsk_treeseq_get_num_nodes(self->tree_sequence);\n for (u = 0; u < num_nodes; u++) {\n left_child = self->left_child[u];\n if (left_child != TSK_NULL && left_child == self->right_child[u]) {\n ret = tsk_trace_error(TSK_ERR_UNARY_NODES);\n goto out;\n }\n }\nout:\n return ret;\n}\n\nstatic int\ncheck_kc_distance_samples_inputs(const tsk_treeseq_t *self, const tsk_treeseq_t *other)\n{\n const tsk_id_t *samples, *other_samples;\n tsk_id_t i, n;\n int ret = 0;\n\n if (self->num_samples != other->num_samples) {\n ret = tsk_trace_error(TSK_ERR_SAMPLE_SIZE_MISMATCH);\n goto out;\n }\n\n samples = self->samples;\n other_samples = other->samples;\n n = (tsk_id_t) self->num_samples;\n for (i = 0; i < n; i++) {\n if (samples[i] != other_samples[i]) {\n ret = tsk_trace_error(TSK_ERR_SAMPLES_NOT_EQUAL);\n goto out;\n }\n }\nout:\n return ret;\n}\n\nint\ntsk_tree_kc_distance(\n const tsk_tree_t *self, const tsk_tree_t *other, double lambda, double *result)\n{\n tsk_id_t n, i;\n kc_vectors vecs[2];\n const tsk_tree_t *trees[2] = { self, other };\n int ret = 0;\n\n for (i = 0; i < 2; i++) {\n tsk_memset(&vecs[i], 0, sizeof(kc_vectors));\n }\n\n ret = check_kc_distance_samples_inputs(self->tree_sequence, other->tree_sequence);\n if (ret != 0) {\n goto out;\n }\n for (i = 0; i < 2; i++) {\n ret = check_kc_distance_tree_inputs(trees[i]);\n if (ret != 0) {\n goto out;\n }\n }\n\n n = (tsk_id_t) self->tree_sequence->num_samples;\n for (i = 0; i < 2; i++) {\n ret = kc_vectors_alloc(&vecs[i], n);\n if (ret != 0) {\n goto out;\n }\n ret = fill_kc_vectors(trees[i], &vecs[i]);\n if (ret != 0) {\n goto out;\n }\n }\n\n *result = norm_kc_vectors(&vecs[0], &vecs[1], lambda);\nout:\n for (i = 0; i < 2; i++) {\n kc_vectors_free(&vecs[i]);\n }\n return ret;\n}\n\nstatic int\ncheck_kc_distance_tree_sequence_inputs(\n const tsk_treeseq_t *self, const tsk_treeseq_t *other)\n{\n int ret = 0;\n\n if (self->tables->sequence_length != other->tables->sequence_length) {\n ret = tsk_trace_error(TSK_ERR_SEQUENCE_LENGTH_MISMATCH);\n goto out;\n }\n\n ret = check_kc_distance_samples_inputs(self, other);\n if (ret != 0) {\n goto out;\n }\n\nout:\n return ret;\n}\n\nstatic void\nupdate_kc_pair_with_sample(const tsk_tree_t *self, kc_vectors *kc, tsk_id_t sample,\n tsk_size_t *depths, double root_time)\n{\n tsk_id_t c, p, sib;\n double time;\n tsk_size_t depth;\n double *times = self->tree_sequence->tables->nodes.time;\n\n c = sample;\n for (p = self->parent[sample]; p != TSK_NULL; p = self->parent[p]) {\n time = root_time - times[p];\n depth = depths[p];\n for (sib = self->left_child[p]; sib != TSK_NULL; sib = self->right_sib[sib]) {\n if (sib != c) {\n update_kc_vectors_all_pairs(self, kc, sample, sib, depth, time);\n }\n }\n c = p;\n }\n}\n\nstatic int\nupdate_kc_subtree_state(\n tsk_tree_t *t, kc_vectors *kc, tsk_id_t u, tsk_size_t *depths, double root_time)\n{\n int stack_top;\n tsk_id_t v, c;\n tsk_id_t *stack = NULL;\n int ret = 0;\n\n stack = tsk_malloc(tsk_tree_get_size_bound(t) * sizeof(*stack));\n if (stack == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n stack_top = 0;\n stack[stack_top] = u;\n while (stack_top >= 0) {\n v = stack[stack_top];\n stack_top--;\n\n if (tsk_tree_is_sample(t, v)) {\n update_kc_pair_with_sample(t, kc, v, depths, root_time);\n }\n for (c = t->left_child[v]; c != TSK_NULL; c = t->right_sib[c]) {\n if (depths[c] != 0) {\n depths[c] = depths[v] + 1;\n stack_top++;\n stack[stack_top] = c;\n }\n }\n }\n\nout:\n tsk_safe_free(stack);\n return ret;\n}\n\nstatic int\nupdate_kc_incremental(tsk_tree_t *tree, kc_vectors *kc, tsk_size_t *depths)\n{\n int ret = 0;\n tsk_id_t u, v, e, j;\n double root_time, time;\n const double *restrict times = tree->tree_sequence->tables->nodes.time;\n const tsk_id_t *restrict edges_child = tree->tree_sequence->tables->edges.child;\n const tsk_id_t *restrict edges_parent = tree->tree_sequence->tables->edges.parent;\n tsk_tree_position_t tree_pos = tree->tree_pos;\n\n /* Update state of detached subtrees */\n for (j = tree_pos.out.stop - 1; j >= tree_pos.out.start; j--) {\n e = tree_pos.out.order[j];\n u = edges_child[e];\n depths[u] = 0;\n\n if (tree->parent[u] == TSK_NULL) {\n root_time = times[tsk_tree_node_root(tree, u)];\n ret = update_kc_subtree_state(tree, kc, u, depths, root_time);\n if (ret != 0) {\n goto out;\n }\n }\n }\n\n /* Propagate state change down into reattached subtrees. */\n for (j = tree_pos.in.stop - 1; j >= tree_pos.in.start; j--) {\n e = tree_pos.in.order[j];\n u = edges_child[e];\n v = edges_parent[e];\n\n tsk_bug_assert(depths[u] == 0);\n depths[u] = depths[v] + 1;\n\n root_time = times[tsk_tree_node_root(tree, u)];\n ret = update_kc_subtree_state(tree, kc, u, depths, root_time);\n if (ret != 0) {\n goto out;\n }\n\n if (tsk_tree_is_sample(tree, u)) {\n time = tsk_tree_get_branch_length_unsafe(tree, u);\n update_kc_vectors_single_sample(tree->tree_sequence, kc, u, time);\n }\n }\nout:\n return ret;\n}\n\nint\ntsk_treeseq_kc_distance(const tsk_treeseq_t *self, const tsk_treeseq_t *other,\n double lambda_, double *result)\n{\n int i;\n tsk_id_t n;\n tsk_size_t num_nodes;\n double left, span, total;\n const tsk_treeseq_t *treeseqs[2] = { self, other };\n tsk_tree_t trees[2];\n kc_vectors kcs[2];\n tsk_size_t *depths[2];\n int ret = 0;\n\n for (i = 0; i < 2; i++) {\n tsk_memset(&trees[i], 0, sizeof(trees[i]));\n tsk_memset(&kcs[i], 0, sizeof(kcs[i]));\n depths[i] = NULL;\n }\n\n ret = check_kc_distance_tree_sequence_inputs(self, other);\n if (ret != 0) {\n goto out;\n }\n\n n = (tsk_id_t) self->num_samples;\n for (i = 0; i < 2; i++) {\n ret = tsk_tree_init(&trees[i], treeseqs[i], TSK_SAMPLE_LISTS);\n if (ret != 0) {\n goto out;\n }\n ret = kc_vectors_alloc(&kcs[i], n);\n if (ret != 0) {\n goto out;\n }\n num_nodes = tsk_treeseq_get_num_nodes(treeseqs[i]);\n depths[i] = tsk_calloc(num_nodes, sizeof(*depths[i]));\n if (depths[i] == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n }\n\n total = 0;\n left = 0;\n\n ret = tsk_tree_first(&trees[0]);\n if (ret != TSK_TREE_OK) {\n goto out;\n }\n ret = check_kc_distance_tree_inputs(&trees[0]);\n if (ret != 0) {\n goto out;\n }\n\n ret = update_kc_incremental(&trees[0], &kcs[0], depths[0]);\n if (ret != 0) {\n goto out;\n }\n while ((ret = tsk_tree_next(&trees[1])) == TSK_TREE_OK) {\n ret = check_kc_distance_tree_inputs(&trees[1]);\n if (ret != 0) {\n goto out;\n }\n\n ret = update_kc_incremental(&trees[1], &kcs[1], depths[1]);\n if (ret != 0) {\n goto out;\n }\n while (trees[0].interval.right < trees[1].interval.right) {\n span = trees[0].interval.right - left;\n total += norm_kc_vectors(&kcs[0], &kcs[1], lambda_) * span;\n\n left = trees[0].interval.right;\n ret = tsk_tree_next(&trees[0]);\n tsk_bug_assert(ret == TSK_TREE_OK);\n ret = check_kc_distance_tree_inputs(&trees[0]);\n if (ret != 0) {\n goto out;\n }\n ret = update_kc_incremental(&trees[0], &kcs[0], depths[0]);\n if (ret != 0) {\n goto out;\n }\n }\n span = trees[1].interval.right - left;\n left = trees[1].interval.right;\n total += norm_kc_vectors(&kcs[0], &kcs[1], lambda_) * span;\n }\n if (ret != 0) {\n goto out;\n }\n\n *result = total / self->tables->sequence_length;\nout:\n for (i = 0; i < 2; i++) {\n tsk_tree_free(&trees[i]);\n kc_vectors_free(&kcs[i]);\n tsk_safe_free(depths[i]);\n }\n return ret;\n}\n\n/*\n * Divergence matrix\n */\n\ntypedef struct {\n /* Note it's a waste storing the triply linked tree here, but the code\n * is written on the assumption of 1-based trees and the algorithm is\n * frighteningly subtle, so it doesn't seem worth messing with it\n * unless we really need to save some memory */\n tsk_id_t *parent;\n tsk_id_t *child;\n tsk_id_t *sib;\n tsk_id_t *lambda;\n tsk_id_t *pi;\n tsk_id_t *tau;\n tsk_id_t *beta;\n tsk_id_t *alpha;\n} sv_tables_t;\n\nstatic int\nsv_tables_init(sv_tables_t *self, tsk_size_t n)\n{\n int ret = 0;\n\n self->parent = tsk_malloc(n * sizeof(*self->parent));\n self->child = tsk_malloc(n * sizeof(*self->child));\n self->sib = tsk_malloc(n * sizeof(*self->sib));\n self->pi = tsk_malloc(n * sizeof(*self->pi));\n self->lambda = tsk_malloc(n * sizeof(*self->lambda));\n self->tau = tsk_malloc(n * sizeof(*self->tau));\n self->beta = tsk_malloc(n * sizeof(*self->beta));\n self->alpha = tsk_malloc(n * sizeof(*self->alpha));\n if (self->parent == NULL || self->child == NULL || self->sib == NULL\n || self->lambda == NULL || self->tau == NULL || self->beta == NULL\n || self->alpha == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int\nsv_tables_free(sv_tables_t *self)\n{\n tsk_safe_free(self->parent);\n tsk_safe_free(self->child);\n tsk_safe_free(self->sib);\n tsk_safe_free(self->lambda);\n tsk_safe_free(self->pi);\n tsk_safe_free(self->tau);\n tsk_safe_free(self->beta);\n tsk_safe_free(self->alpha);\n return 0;\n}\nstatic void\nsv_tables_reset(sv_tables_t *self, tsk_tree_t *tree)\n{\n const tsk_size_t n = 1 + tree->num_nodes;\n tsk_memset(self->parent, 0, n * sizeof(*self->parent));\n tsk_memset(self->child, 0, n * sizeof(*self->child));\n tsk_memset(self->sib, 0, n * sizeof(*self->sib));\n tsk_memset(self->pi, 0, n * sizeof(*self->pi));\n tsk_memset(self->lambda, 0, n * sizeof(*self->lambda));\n tsk_memset(self->tau, 0, n * sizeof(*self->tau));\n tsk_memset(self->beta, 0, n * sizeof(*self->beta));\n tsk_memset(self->alpha, 0, n * sizeof(*self->alpha));\n}\n\nstatic void\nsv_tables_convert_tree(sv_tables_t *self, tsk_tree_t *tree)\n{\n const tsk_size_t n = 1 + tree->num_nodes;\n const tsk_id_t *restrict tsk_parent = tree->parent;\n tsk_id_t *restrict child = self->child;\n tsk_id_t *restrict parent = self->parent;\n tsk_id_t *restrict sib = self->sib;\n tsk_size_t j;\n tsk_id_t u, v;\n\n for (j = 0; j < n - 1; j++) {\n u = (tsk_id_t) j + 1;\n v = tsk_parent[j] + 1;\n sib[u] = child[v];\n child[v] = u;\n parent[u] = v;\n }\n}\n\n#define LAMBDA 0\n\nstatic void\nsv_tables_build_index(sv_tables_t *self)\n{\n const tsk_id_t *restrict child = self->child;\n const tsk_id_t *restrict parent = self->parent;\n const tsk_id_t *restrict sib = self->sib;\n tsk_id_t *restrict lambda = self->lambda;\n tsk_id_t *restrict pi = self->pi;\n tsk_id_t *restrict tau = self->tau;\n tsk_id_t *restrict beta = self->beta;\n tsk_id_t *restrict alpha = self->alpha;\n tsk_id_t a, n, p, h;\n\n p = child[LAMBDA];\n n = 0;\n lambda[0] = -1;\n while (p != LAMBDA) {\n while (true) {\n n++;\n pi[p] = n;\n tau[n] = LAMBDA;\n lambda[n] = 1 + lambda[n >> 1];\n if (child[p] != LAMBDA) {\n p = child[p];\n } else {\n break;\n }\n }\n beta[p] = n;\n while (true) {\n tau[beta[p]] = parent[p];\n if (sib[p] != LAMBDA) {\n p = sib[p];\n break;\n } else {\n p = parent[p];\n if (p != LAMBDA) {\n h = lambda[n & -pi[p]];\n beta[p] = ((n >> h) | 1) << h;\n } else {\n break;\n }\n }\n }\n }\n\n /* Begin the second traversal */\n lambda[0] = lambda[n];\n pi[LAMBDA] = 0;\n beta[LAMBDA] = 0;\n alpha[LAMBDA] = 0;\n p = child[LAMBDA];\n while (p != LAMBDA) {\n while (true) {\n a = alpha[parent[p]] | (beta[p] & -beta[p]);\n alpha[p] = a;\n if (child[p] != LAMBDA) {\n p = child[p];\n } else {\n break;\n }\n }\n while (true) {\n if (sib[p] != LAMBDA) {\n p = sib[p];\n break;\n } else {\n p = parent[p];\n if (p == LAMBDA) {\n break;\n }\n }\n }\n }\n}\n\nstatic void\nsv_tables_build(sv_tables_t *self, tsk_tree_t *tree)\n{\n sv_tables_reset(self, tree);\n sv_tables_convert_tree(self, tree);\n sv_tables_build_index(self);\n}\n\nstatic tsk_id_t\nsv_tables_mrca_one_based(const sv_tables_t *self, tsk_id_t x, tsk_id_t y)\n{\n const tsk_id_t *restrict lambda = self->lambda;\n const tsk_id_t *restrict pi = self->pi;\n const tsk_id_t *restrict tau = self->tau;\n const tsk_id_t *restrict beta = self->beta;\n const tsk_id_t *restrict alpha = self->alpha;\n tsk_id_t h, k, xhat, yhat, ell, j, z;\n\n if (beta[x] <= beta[y]) {\n h = lambda[beta[y] & -beta[x]];\n } else {\n h = lambda[beta[x] & -beta[y]];\n }\n k = alpha[x] & alpha[y] & -(1 << h);\n h = lambda[k & -k];\n j = ((beta[x] >> h) | 1) << h;\n if (j == beta[x]) {\n xhat = x;\n } else {\n ell = lambda[alpha[x] & ((1 << h) - 1)];\n xhat = tau[((beta[x] >> ell) | 1) << ell];\n }\n if (j == beta[y]) {\n yhat = y;\n } else {\n ell = lambda[alpha[y] & ((1 << h) - 1)];\n yhat = tau[((beta[y] >> ell) | 1) << ell];\n }\n if (pi[xhat] <= pi[yhat]) {\n z = xhat;\n } else {\n z = yhat;\n }\n return z;\n}\n\nstatic tsk_id_t\nsv_tables_mrca(const sv_tables_t *self, tsk_id_t x, tsk_id_t y)\n{\n /* Convert to 1-based indexes and back */\n return sv_tables_mrca_one_based(self, x + 1, y + 1) - 1;\n}\n\nstatic int\ntsk_treeseq_divergence_matrix_branch(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *restrict sample_set_sizes,\n const tsk_id_t *restrict sample_sets, tsk_size_t num_windows,\n const double *restrict windows, tsk_flags_t options, double *restrict result)\n{\n int ret = 0;\n tsk_tree_t tree;\n const double *restrict nodes_time = self->tables->nodes.time;\n const tsk_size_t N = num_sample_sets;\n tsk_size_t i, j, k, offset, sj, sk;\n tsk_id_t u, v, w, u_root, v_root;\n double tu, tv, d, span, left, right, span_left, span_right;\n double *restrict D;\n sv_tables_t sv;\n tsk_size_t *ss_offsets = tsk_malloc((num_sample_sets + 1) * sizeof(*ss_offsets));\n\n memset(&sv, 0, sizeof(sv));\n ret = tsk_tree_init(&tree, self, 0);\n if (ret != 0) {\n goto out;\n }\n ret = sv_tables_init(&sv, self->tables->nodes.num_rows + 1);\n if (ret != 0) {\n goto out;\n }\n if (ss_offsets == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n if (self->time_uncalibrated && !(options & TSK_STAT_ALLOW_TIME_UNCALIBRATED)) {\n ret = tsk_trace_error(TSK_ERR_TIME_UNCALIBRATED);\n goto out;\n }\n\n ss_offsets[0] = 0;\n offset = 0;\n for (j = 0; j < N; j++) {\n offset += sample_set_sizes[j];\n ss_offsets[j + 1] = offset;\n }\n\n for (i = 0; i < num_windows; i++) {\n left = windows[i];\n right = windows[i + 1];\n D = result + i * N * N;\n ret = tsk_tree_seek(&tree, left, 0);\n if (ret != 0) {\n goto out;\n }\n while (tree.interval.left < right && tree.index != -1) {\n span_left = TSK_MAX(tree.interval.left, left);\n span_right = TSK_MIN(tree.interval.right, right);\n span = span_right - span_left;\n sv_tables_build(&sv, &tree);\n for (sj = 0; sj < N; sj++) {\n for (j = ss_offsets[sj]; j < ss_offsets[sj + 1]; j++) {\n u = sample_sets[j];\n for (sk = sj; sk < N; sk++) {\n for (k = ss_offsets[sk]; k < ss_offsets[sk + 1]; k++) {\n v = sample_sets[k];\n if (u == v) {\n /* This case contributes zero to divergence, so\n * short-circuit to save time.\n * TODO is there a better way to do this? */\n continue;\n }\n w = sv_tables_mrca(&sv, u, v);\n if (w != TSK_NULL) {\n u_root = w;\n v_root = w;\n } else {\n /* Slow path - only happens for nodes in disconnected\n * subtrees in a tree with multiple roots */\n u_root = tsk_tree_get_node_root(&tree, u);\n v_root = tsk_tree_get_node_root(&tree, v);\n }\n tu = nodes_time[u_root] - nodes_time[u];\n tv = nodes_time[v_root] - nodes_time[v];\n d = (tu + tv) * span;\n D[sj * N + sk] += d;\n }\n }\n }\n }\n ret = tsk_tree_next(&tree);\n if (ret < 0) {\n goto out;\n }\n }\n }\n ret = 0;\nout:\n tsk_tree_free(&tree);\n sv_tables_free(&sv);\n tsk_safe_free(ss_offsets);\n return ret;\n}\n\n// FIXME see #2817\n// Just including this here for now as it's the simplest option. Everything\n// will probably move to stats.[c,h] in the near future though, and it\n// can pull in ``genotypes.h`` without issues.\n#include \n\nstatic void\nupdate_site_divergence(const tsk_variant_t *var, const tsk_id_t *restrict A,\n const tsk_size_t *restrict offsets, const tsk_size_t num_sample_sets, double *D)\n\n{\n const tsk_size_t num_alleles = var->num_alleles;\n tsk_size_t a, b, j, k;\n tsk_id_t u, v;\n double increment;\n\n for (a = 0; a < num_alleles; a++) {\n for (b = a + 1; b < num_alleles; b++) {\n for (j = offsets[a]; j < offsets[a + 1]; j++) {\n for (k = offsets[b]; k < offsets[b + 1]; k++) {\n u = A[j];\n v = A[k];\n /* Only increment the upper triangle to (hopefully) improve memory\n * access patterns */\n if (u > v) {\n u = A[k];\n v = A[j];\n }\n increment = 1;\n if (u == v) {\n increment = 2;\n }\n D[u * (tsk_id_t) num_sample_sets + v] += increment;\n }\n }\n }\n }\n}\n\nstatic void\ngroup_alleles(const tsk_variant_t *var, tsk_id_t *restrict A, tsk_size_t *offsets)\n{\n const tsk_size_t n = var->num_samples;\n const int32_t *restrict genotypes = var->genotypes;\n tsk_id_t a;\n tsk_size_t j, k;\n\n k = 0;\n offsets[0] = 0;\n for (a = 0; a < (tsk_id_t) var->num_alleles; a++) {\n offsets[a + 1] = offsets[a];\n for (j = 0; j < n; j++) {\n if (genotypes[j] == a) {\n offsets[a + 1]++;\n A[k] = (tsk_id_t) j;\n k++;\n }\n }\n }\n}\n\nstatic void\nremap_to_sample_sets(const tsk_size_t num_samples, const tsk_id_t *restrict samples,\n const tsk_id_t *restrict sample_set_index_map, tsk_id_t *restrict A)\n{\n tsk_size_t j;\n tsk_id_t u;\n for (j = 0; j < num_samples; j++) {\n u = samples[A[j]];\n tsk_bug_assert(u >= 0);\n tsk_bug_assert(sample_set_index_map[u] >= 0);\n A[j] = sample_set_index_map[u];\n }\n}\n\nstatic int\ntsk_treeseq_divergence_matrix_site(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_id_t *restrict sample_set_index_map, const tsk_size_t num_samples,\n const tsk_id_t *restrict samples, tsk_size_t num_windows,\n const double *restrict windows, tsk_flags_t TSK_UNUSED(options),\n double *restrict result)\n{\n int ret = 0;\n tsk_size_t i;\n tsk_id_t site_id;\n double left, right;\n double *restrict D;\n const tsk_id_t num_sites = (tsk_id_t) self->tables->sites.num_rows;\n const double *restrict sites_position = self->tables->sites.position;\n tsk_id_t *A = tsk_malloc(num_samples * sizeof(*A));\n /* Allocate the allele offsets at the first variant */\n tsk_size_t max_alleles = 0;\n tsk_size_t *allele_offsets = NULL;\n tsk_variant_t variant;\n\n /* FIXME it's not clear that using TSK_ISOLATED_NOT_MISSING is\n * correct here */\n ret = tsk_variant_init(\n &variant, self, samples, num_samples, NULL, TSK_ISOLATED_NOT_MISSING);\n if (ret != 0) {\n goto out;\n }\n if (A == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n site_id = 0;\n while (site_id < num_sites && sites_position[site_id] < windows[0]) {\n site_id++;\n }\n\n for (i = 0; i < num_windows; i++) {\n left = windows[i];\n right = windows[i + 1];\n D = result + i * num_sample_sets * num_sample_sets;\n\n if (site_id < num_sites) {\n tsk_bug_assert(sites_position[site_id] >= left);\n }\n while (site_id < num_sites && sites_position[site_id] < right) {\n ret = tsk_variant_decode(&variant, site_id, 0);\n if (ret != 0) {\n goto out;\n }\n if (variant.num_alleles > max_alleles) {\n /* could do some kind of doubling here, but there's no\n * point - just keep it simple for testing. */\n max_alleles = variant.num_alleles;\n tsk_safe_free(allele_offsets);\n allele_offsets = tsk_malloc((max_alleles + 1) * sizeof(*allele_offsets));\n if (allele_offsets == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n }\n group_alleles(&variant, A, allele_offsets);\n remap_to_sample_sets(num_samples, samples, sample_set_index_map, A);\n update_site_divergence(&variant, A, allele_offsets, num_sample_sets, D);\n site_id++;\n }\n }\n ret = 0;\nout:\n tsk_variant_free(&variant);\n tsk_safe_free(A);\n tsk_safe_free(allele_offsets);\n return ret;\n}\n\n/* Return the mapping from node IDs to the index of the sample set\n * they belong to, or -1 of none. Error if a node is in more than one\n * set.\n */\nstatic int\nget_sample_set_index_map(const tsk_treeseq_t *self, const tsk_size_t num_sample_sets,\n const tsk_size_t *restrict sample_set_sizes, const tsk_id_t *restrict sample_sets,\n tsk_size_t *ret_total_samples, tsk_id_t *restrict node_index_map)\n{\n int ret = 0;\n tsk_size_t i, j, k;\n tsk_id_t u;\n tsk_size_t total_samples = 0;\n const tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const tsk_flags_t *restrict node_flags = self->tables->nodes.flags;\n\n for (j = 0; j < num_nodes; j++) {\n node_index_map[j] = TSK_NULL;\n }\n i = 0;\n for (j = 0; j < num_sample_sets; j++) {\n total_samples += sample_set_sizes[j];\n for (k = 0; k < sample_set_sizes[j]; k++) {\n u = sample_sets[i];\n i++;\n if (u < 0 || u >= (tsk_id_t) num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n /* Note: we require nodes to be samples because we have to think\n * about how to normalise by the length of genome that the node\n * is 'in' the tree for each window otherwise. */\n if (!(node_flags[u] & TSK_NODE_IS_SAMPLE)) {\n ret = tsk_trace_error(TSK_ERR_BAD_SAMPLES);\n goto out;\n }\n if (node_index_map[u] != TSK_NULL) {\n ret = tsk_trace_error(TSK_ERR_DUPLICATE_SAMPLE);\n goto out;\n }\n node_index_map[u] = (tsk_id_t) j;\n }\n }\n *ret_total_samples = total_samples;\nout:\n return ret;\n}\n\nstatic void\nfill_lower_triangle_count_normalise(const tsk_size_t num_windows, const tsk_size_t n,\n const tsk_size_t *set_sizes, double *restrict result)\n{\n tsk_size_t i, j, k;\n double denom;\n double *restrict D;\n\n /* TODO there's probably a better striding pattern that could be used here */\n for (i = 0; i < num_windows; i++) {\n D = result + i * n * n;\n for (j = 0; j < n; j++) {\n denom = (double) set_sizes[j] * (double) (set_sizes[j] - 1);\n if (denom != 0) {\n D[j * n + j] /= denom;\n }\n for (k = j + 1; k < n; k++) {\n denom = (double) set_sizes[j] * (double) set_sizes[k];\n D[j * n + k] /= denom;\n D[k * n + j] = D[j * n + k];\n }\n }\n }\n}\n\nint\ntsk_treeseq_divergence_matrix(const tsk_treeseq_t *self, tsk_size_t num_sample_sets_in,\n const tsk_size_t *sample_set_sizes_in, const tsk_id_t *sample_sets_in,\n tsk_size_t num_windows, const double *windows, tsk_flags_t options, double *result)\n{\n int ret = 0;\n tsk_size_t N, total_samples;\n const tsk_size_t *sample_set_sizes;\n const tsk_id_t *sample_sets;\n tsk_size_t *tmp_sample_set_sizes = NULL;\n const double default_windows[] = { 0, self->tables->sequence_length };\n const tsk_size_t num_nodes = self->tables->nodes.num_rows;\n bool stat_site = !!(options & TSK_STAT_SITE);\n bool stat_branch = !!(options & TSK_STAT_BRANCH);\n bool stat_node = !!(options & TSK_STAT_NODE);\n tsk_id_t *sample_set_index_map\n = tsk_malloc(num_nodes * sizeof(*sample_set_index_map));\n tsk_size_t j;\n\n if (stat_node) {\n ret = tsk_trace_error(TSK_ERR_UNSUPPORTED_STAT_MODE);\n goto out;\n }\n /* If no mode is specified, we default to site mode */\n if (!(stat_site || stat_branch)) {\n stat_site = true;\n }\n /* It's an error to specify more than one mode */\n if (stat_site + stat_branch > 1) {\n ret = tsk_trace_error(TSK_ERR_MULTIPLE_STAT_MODES);\n goto out;\n }\n\n if (options & TSK_STAT_POLARISED) {\n ret = tsk_trace_error(TSK_ERR_STAT_POLARISED_UNSUPPORTED);\n goto out;\n }\n\n if (windows == NULL) {\n num_windows = 1;\n windows = default_windows;\n } else {\n ret = tsk_treeseq_check_windows(self, num_windows, windows, 0);\n if (ret != 0) {\n goto out;\n }\n }\n\n /* If sample_sets is NULL, use self->samples and ignore input\n * num_sample_sets */\n sample_sets = sample_sets_in;\n N = num_sample_sets_in;\n if (sample_sets_in == NULL) {\n sample_sets = self->samples;\n if (sample_set_sizes_in == NULL) {\n N = self->num_samples;\n }\n }\n sample_set_sizes = sample_set_sizes_in;\n /* If sample_set_sizes is NULL, assume its N 1S */\n if (sample_set_sizes_in == NULL) {\n tmp_sample_set_sizes = tsk_malloc(N * sizeof(*tmp_sample_set_sizes));\n if (tmp_sample_set_sizes == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n for (j = 0; j < N; j++) {\n tmp_sample_set_sizes[j] = 1;\n }\n sample_set_sizes = tmp_sample_set_sizes;\n }\n\n ret = get_sample_set_index_map(\n self, N, sample_set_sizes, sample_sets, &total_samples, sample_set_index_map);\n if (ret != 0) {\n goto out;\n }\n\n tsk_memset(result, 0, num_windows * N * N * sizeof(*result));\n\n if (stat_branch) {\n ret = tsk_treeseq_divergence_matrix_branch(self, N, sample_set_sizes,\n sample_sets, num_windows, windows, options, result);\n } else {\n tsk_bug_assert(stat_site);\n ret = tsk_treeseq_divergence_matrix_site(self, N, sample_set_index_map,\n total_samples, sample_sets, num_windows, windows, options, result);\n }\n if (ret != 0) {\n goto out;\n }\n fill_lower_triangle_count_normalise(num_windows, N, sample_set_sizes, result);\n\n if (options & TSK_STAT_SPAN_NORMALISE) {\n span_normalise(num_windows, windows, N * N, result);\n }\nout:\n tsk_safe_free(sample_set_index_map);\n tsk_safe_free(tmp_sample_set_sizes);\n return ret;\n}\n\n/* ======================================================== *\n * Extend haplotypes\n * ======================================================== */\n\ntypedef struct _edge_list_t {\n tsk_id_t edge;\n // the `extended` flags records whether we have decided to extend\n // this entry to the current tree?\n int extended;\n struct _edge_list_t *next;\n} edge_list_t;\n\nstatic void\nedge_list_print(edge_list_t **head, tsk_edge_table_t *edges, FILE *out)\n{\n int n = 0;\n edge_list_t *px;\n fprintf(out, \"Edge list:\\n\");\n for (px = *head; px != NULL; px = px->next) {\n fprintf(out, \" %d: %d (%d); \", n, (int) px->edge, px->extended);\n if (px->edge >= 0 && edges != NULL) {\n fprintf(out, \"%d->%d on [%.1f, %.1f)\", (int) edges->child[px->edge],\n (int) edges->parent[px->edge], edges->left[px->edge],\n edges->right[px->edge]);\n } else {\n fprintf(out, \"(null)\");\n }\n fprintf(out, \"\\n\");\n n += 1;\n }\n fprintf(out, \"length = %d\\n\", n);\n}\n\nstatic void\nedge_list_append_entry(\n edge_list_t **head, edge_list_t **tail, edge_list_t *x, tsk_id_t edge, int extended)\n{\n x->edge = edge;\n x->extended = extended;\n x->next = NULL;\n\n if (*tail == NULL) {\n *head = x;\n } else {\n (*tail)->next = x;\n }\n *tail = x;\n}\n\nstatic void\nremove_unextended(edge_list_t **head, edge_list_t **tail)\n{\n edge_list_t *px, *x;\n\n px = *head;\n while (px != NULL && px->extended == 0) {\n px = px->next;\n }\n *head = px;\n if (px != NULL) {\n px->extended = 0;\n x = px->next;\n while (x != NULL) {\n if (x->extended > 0) {\n x->extended = 0;\n px->next = x;\n px = x;\n }\n x = x->next;\n }\n px->next = NULL;\n }\n *tail = px;\n}\n\nstatic void\nedge_list_set_extended(edge_list_t **head, tsk_id_t edge_id)\n{\n // finds the entry with edge 'edge_id'\n // and sets its 'extended' flag to 1\n edge_list_t *px;\n px = *head;\n tsk_bug_assert(px != NULL);\n while (px->edge != edge_id) {\n px = px->next;\n tsk_bug_assert(px != NULL);\n }\n tsk_bug_assert(px->edge == edge_id);\n px->extended = 1;\n}\n\nstatic int\ntsk_treeseq_slide_mutation_nodes_up(\n const tsk_treeseq_t *self, tsk_mutation_table_t *mutations)\n{\n int ret = 0;\n double t;\n tsk_id_t c, p, next_mut;\n const tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const double *sites_position = self->tables->sites.position;\n const double *nodes_time = self->tables->nodes.time;\n tsk_tree_t tree;\n\n ret = tsk_tree_init(&tree, self, TSK_NO_SAMPLE_COUNTS);\n if (ret != 0) {\n goto out;\n }\n\n next_mut = 0;\n for (ret = tsk_tree_first(&tree); ret == TSK_TREE_OK; ret = tsk_tree_next(&tree)) {\n while (next_mut < (tsk_id_t) mutations->num_rows\n && sites_position[mutations->site[next_mut]] < tree.interval.right) {\n t = mutations->time[next_mut];\n if (tsk_is_unknown_time(t)) {\n ret = tsk_trace_error(TSK_ERR_DISALLOWED_UNKNOWN_MUTATION_TIME);\n goto out;\n }\n c = mutations->node[next_mut];\n tsk_bug_assert(c < (tsk_id_t) num_nodes);\n p = tree.parent[c];\n while (p != TSK_NULL && nodes_time[p] <= t) {\n c = p;\n p = tree.parent[c];\n }\n tsk_bug_assert(nodes_time[c] <= t);\n mutations->node[next_mut] = c;\n next_mut++;\n }\n }\n if (ret != 0) {\n goto out;\n }\n\nout:\n tsk_tree_free(&tree);\n\n return ret;\n}\n\ntypedef struct {\n const tsk_treeseq_t *ts;\n tsk_edge_table_t *edges;\n int direction;\n tsk_id_t *last_degree, *next_degree;\n tsk_id_t *last_nodes_edge, *next_nodes_edge;\n tsk_id_t *parent_out, *parent_in;\n bool *not_sample;\n double *near_side, *far_side;\n edge_list_t *edges_out_head, *edges_out_tail;\n edge_list_t *edges_in_head, *edges_in_tail;\n tsk_blkalloc_t edge_list_heap;\n} haplotype_extender_t;\n\nstatic int\nhaplotype_extender_init(haplotype_extender_t *self, const tsk_treeseq_t *ts,\n int direction, tsk_edge_table_t *edges)\n{\n int ret = 0;\n tsk_id_t tj;\n tsk_size_t num_nodes = tsk_treeseq_get_num_nodes(ts);\n\n tsk_memset(self, 0, sizeof(haplotype_extender_t));\n\n self->ts = ts;\n self->edges = edges;\n ret = tsk_edge_table_copy(&ts->tables->edges, self->edges, TSK_NO_INIT);\n if (ret != 0) {\n goto out;\n }\n\n self->direction = direction;\n if (direction == TSK_DIR_FORWARD) {\n self->near_side = self->edges->left;\n self->far_side = self->edges->right;\n } else {\n self->near_side = self->edges->right;\n self->far_side = self->edges->left;\n }\n\n self->edges_in_head = NULL;\n self->edges_in_tail = NULL;\n self->edges_out_head = NULL;\n self->edges_out_tail = NULL;\n\n ret = tsk_blkalloc_init(&self->edge_list_heap, 8192);\n if (ret != 0) {\n goto out;\n }\n\n self->last_degree = tsk_calloc(num_nodes, sizeof(*self->last_degree));\n self->next_degree = tsk_calloc(num_nodes, sizeof(*self->next_degree));\n self->last_nodes_edge = tsk_malloc(num_nodes * sizeof(*self->last_nodes_edge));\n self->next_nodes_edge = tsk_malloc(num_nodes * sizeof(*self->next_nodes_edge));\n self->parent_out = tsk_malloc(num_nodes * sizeof(*self->parent_out));\n self->parent_in = tsk_malloc(num_nodes * sizeof(*self->parent_in));\n self->not_sample = tsk_malloc(num_nodes * sizeof(*self->not_sample));\n\n if (self->last_degree == NULL || self->next_degree == NULL\n || self->last_nodes_edge == NULL || self->next_nodes_edge == NULL\n || self->parent_out == NULL || self->parent_in == NULL\n || self->not_sample == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n tsk_memset(self->last_nodes_edge, 0xff, num_nodes * sizeof(*self->last_nodes_edge));\n tsk_memset(self->next_nodes_edge, 0xff, num_nodes * sizeof(*self->next_nodes_edge));\n tsk_memset(self->parent_out, 0xff, num_nodes * sizeof(*self->parent_out));\n tsk_memset(self->parent_in, 0xff, num_nodes * sizeof(*self->parent_in));\n\n for (tj = 0; tj < (tsk_id_t) num_nodes; tj++) {\n self->not_sample[tj] = ((ts->tables->nodes.flags[tj] & TSK_NODE_IS_SAMPLE) == 0);\n }\n\nout:\n return ret;\n}\n\nstatic void\nhaplotype_extender_print_state(haplotype_extender_t *self, FILE *out)\n{\n fprintf(out, \"\\n======= haplotype extender ===========\\n\");\n fprintf(out, \"parent in:\\n\");\n for (int j = 0; j < (int) self->ts->tables->nodes.num_rows; j++) {\n fprintf(out, \" %d: %d\\n\", j, (int) self->parent_in[j]);\n }\n fprintf(out, \"parent out:\\n\");\n for (int j = 0; j < (int) self->ts->tables->nodes.num_rows; j++) {\n fprintf(out, \" %d: %d\\n\", j, (int) self->parent_out[j]);\n }\n fprintf(out, \"last nodes edge:\\n\");\n for (int j = 0; j < (int) self->ts->tables->nodes.num_rows; j++) {\n tsk_id_t ej = self->last_nodes_edge[j];\n fprintf(out, \" %d: %d, \", j, (int) ej);\n if (self->last_nodes_edge[j] != TSK_NULL) {\n fprintf(out, \"(%d->%d, %.1f-%.1f)\", (int) self->edges->child[ej],\n (int) self->edges->parent[ej], self->edges->left[ej],\n self->edges->right[ej]);\n } else {\n fprintf(out, \"(null);\");\n }\n fprintf(out, \"\\n\");\n }\n fprintf(out, \"next nodes edge:\\n\");\n for (int j = 0; j < (int) self->ts->tables->nodes.num_rows; j++) {\n tsk_id_t ej = self->next_nodes_edge[j];\n fprintf(out, \" %d: %d, \", j, (int) ej);\n if (self->next_nodes_edge[j] != TSK_NULL) {\n fprintf(out, \"(%d->%d, %.1f-%.1f)\", (int) self->edges->child[ej],\n (int) self->edges->parent[ej], self->edges->left[ej],\n self->edges->right[ej]);\n } else {\n fprintf(out, \"(null);\");\n }\n fprintf(out, \"\\n\");\n }\n fprintf(out, \"edges out:\\n\");\n edge_list_print(&self->edges_out_head, self->edges, out);\n fprintf(out, \"edges in:\\n\");\n edge_list_print(&self->edges_in_head, self->edges, out);\n}\n\nstatic int\nhaplotype_extender_free(haplotype_extender_t *self)\n{\n tsk_blkalloc_free(&self->edge_list_heap);\n tsk_safe_free(self->last_degree);\n tsk_safe_free(self->next_degree);\n tsk_safe_free(self->last_nodes_edge);\n tsk_safe_free(self->next_nodes_edge);\n tsk_safe_free(self->parent_out);\n tsk_safe_free(self->parent_in);\n tsk_safe_free(self->not_sample);\n return 0;\n}\n\nstatic int\nhaplotype_extender_next_tree(haplotype_extender_t *self, tsk_tree_position_t *tree_pos)\n{\n int ret = 0;\n tsk_id_t tj, e;\n edge_list_t *ex_out, *ex_in;\n edge_list_t *new_ex;\n const tsk_id_t *edges_child = self->edges->child;\n const tsk_id_t *edges_parent = self->edges->parent;\n\n for (ex_out = self->edges_out_head; ex_out != NULL; ex_out = ex_out->next) {\n e = ex_out->edge;\n self->parent_out[edges_child[e]] = TSK_NULL;\n // note we only adjust near_side of edges_in, not edges_out,\n // so no need to check for zero-length edges\n if (ex_out->extended > 1) {\n // this is needed to catch newly-created edges\n self->last_nodes_edge[edges_child[e]] = e;\n self->last_degree[edges_child[e]] += 1;\n self->last_degree[edges_parent[e]] += 1;\n } else if (ex_out->extended == 0) {\n self->last_nodes_edge[edges_child[e]] = TSK_NULL;\n self->last_degree[edges_child[e]] -= 1;\n self->last_degree[edges_parent[e]] -= 1;\n }\n }\n remove_unextended(&self->edges_out_head, &self->edges_out_tail);\n for (ex_in = self->edges_in_head; ex_in != NULL; ex_in = ex_in->next) {\n e = ex_in->edge;\n self->parent_in[edges_child[e]] = TSK_NULL;\n if (ex_in->extended == 0 && self->near_side[e] != self->far_side[e]) {\n self->last_nodes_edge[edges_child[e]] = e;\n self->last_degree[edges_child[e]] += 1;\n self->last_degree[edges_parent[e]] += 1;\n }\n }\n remove_unextended(&self->edges_in_head, &self->edges_in_tail);\n\n // done cleanup from last tree transition;\n // now we set the state up for this tree transition\n for (tj = tree_pos->out.start; tj != tree_pos->out.stop; tj += self->direction) {\n e = tree_pos->out.order[tj];\n if (self->near_side[e] != self->far_side[e]) {\n new_ex = tsk_blkalloc_get(&self->edge_list_heap, sizeof(*new_ex));\n if (new_ex == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n edge_list_append_entry(\n &self->edges_out_head, &self->edges_out_tail, new_ex, e, 0);\n }\n }\n for (ex_out = self->edges_out_head; ex_out != NULL; ex_out = ex_out->next) {\n e = ex_out->edge;\n self->parent_out[edges_child[e]] = edges_parent[e];\n self->next_nodes_edge[edges_child[e]] = TSK_NULL;\n self->next_degree[edges_child[e]] -= 1;\n self->next_degree[edges_parent[e]] -= 1;\n }\n\n for (tj = tree_pos->in.start; tj != tree_pos->in.stop; tj += self->direction) {\n e = tree_pos->in.order[tj];\n // add edge to pending_in\n new_ex = tsk_blkalloc_get(&self->edge_list_heap, sizeof(*new_ex));\n if (new_ex == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n edge_list_append_entry(&self->edges_in_head, &self->edges_in_tail, new_ex, e, 0);\n }\n for (ex_in = self->edges_in_head; ex_in != NULL; ex_in = ex_in->next) {\n e = ex_in->edge;\n self->parent_in[edges_child[e]] = edges_parent[e];\n self->next_nodes_edge[edges_child[e]] = e;\n self->next_degree[edges_child[e]] += 1;\n self->next_degree[edges_parent[e]] += 1;\n }\n\nout:\n return ret;\n}\n\nstatic int\nhaplotype_extender_add_or_extend_edge(haplotype_extender_t *self, tsk_id_t new_parent,\n tsk_id_t child, double left, double right)\n{\n int ret = 0;\n double there;\n tsk_id_t old_edge, e_out, old_parent;\n edge_list_t *ex_in;\n edge_list_t *new_ex = NULL;\n tsk_id_t e_in;\n\n there = (self->direction == TSK_DIR_FORWARD) ? right : left;\n old_edge = self->next_nodes_edge[child];\n if (old_edge != TSK_NULL) {\n old_parent = self->edges->parent[old_edge];\n } else {\n old_parent = TSK_NULL;\n }\n if (new_parent != old_parent) {\n if (self->parent_out[child] == new_parent) {\n // if our new edge is in edges_out, it should be extended\n e_out = self->last_nodes_edge[child];\n self->far_side[e_out] = there;\n edge_list_set_extended(&self->edges_out_head, e_out);\n } else {\n e_out = tsk_edge_table_add_row(\n self->edges, left, right, new_parent, child, NULL, 0);\n if (e_out < 0) {\n ret = (int) e_out;\n goto out;\n }\n /* pointers to left/right might have changed! */\n if (self->direction == TSK_DIR_FORWARD) {\n self->near_side = self->edges->left;\n self->far_side = self->edges->right;\n } else {\n self->near_side = self->edges->right;\n self->far_side = self->edges->left;\n }\n new_ex = tsk_blkalloc_get(&self->edge_list_heap, sizeof(*new_ex));\n if (new_ex == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n edge_list_append_entry(\n &self->edges_out_head, &self->edges_out_tail, new_ex, e_out, 2);\n }\n self->next_nodes_edge[child] = e_out;\n self->next_degree[child] += 1;\n self->next_degree[new_parent] += 1;\n self->parent_out[child] = TSK_NULL;\n if (old_edge != TSK_NULL) {\n for (ex_in = self->edges_in_head; ex_in != NULL; ex_in = ex_in->next) {\n e_in = ex_in->edge;\n if (e_in == old_edge) {\n self->near_side[e_in] = there;\n if (self->far_side[e_in] != there) {\n ex_in->extended = 1;\n }\n self->next_degree[child] -= 1;\n self->next_degree[self->parent_in[child]] -= 1;\n self->parent_in[child] = TSK_NULL;\n }\n }\n }\n }\nout:\n return ret;\n}\n\nstatic float\nhaplotype_extender_mergeable(haplotype_extender_t *self, tsk_id_t c)\n{\n // returns the number of new edges needed\n // if the paths in parent_in and parent_out\n // up through nodes that aren't in the other tree\n // end at the same place and don't have conflicting times;\n // otherwise, return infinity\n tsk_id_t p_in, p_out, child;\n float num_new_edges; // needs to be float so we can have infinity\n int num_extended;\n double t_in, t_out;\n bool climb_in, climb_out;\n const double *nodes_time = self->ts->tables->nodes.time;\n\n p_out = self->parent_out[c];\n p_in = self->parent_in[c];\n t_out = (p_out == TSK_NULL) ? INFINITY : nodes_time[p_out];\n t_in = (p_in == TSK_NULL) ? INFINITY : nodes_time[p_in];\n child = c;\n num_new_edges = 0;\n num_extended = 0;\n while (true) {\n climb_in = (p_in != TSK_NULL && self->last_degree[p_in] == 0\n && self->not_sample[p_in] && t_in < t_out);\n climb_out = (p_out != TSK_NULL && self->next_degree[p_out] == 0\n && self->not_sample[p_out] && t_out < t_in);\n if (climb_in) {\n if (self->parent_in[child] != p_in) {\n num_new_edges += 1;\n }\n child = p_in;\n p_in = self->parent_in[p_in];\n t_in = (p_in == TSK_NULL) ? INFINITY : nodes_time[p_in];\n } else if (climb_out) {\n if (self->parent_out[child] != p_out) {\n num_new_edges += 1;\n }\n child = p_out;\n p_out = self->parent_out[p_out];\n t_out = (p_out == TSK_NULL) ? INFINITY : nodes_time[p_out];\n num_extended += 1;\n } else {\n break;\n }\n }\n if ((num_extended == 0) || (p_in != p_out) || (p_in == TSK_NULL)) {\n num_new_edges = INFINITY;\n }\n return num_new_edges;\n}\n\nstatic int\nhaplotype_extender_merge_paths(\n haplotype_extender_t *self, tsk_id_t c, double left, double right)\n{\n int ret = 0;\n tsk_id_t p_in, p_out, child;\n double t_in, t_out;\n bool climb_in, climb_out;\n const double *nodes_time = self->ts->tables->nodes.time;\n\n p_out = self->parent_out[c];\n p_in = self->parent_in[c];\n t_out = nodes_time[p_out];\n t_in = nodes_time[p_in];\n child = c;\n while (true) {\n climb_in = (p_in != TSK_NULL && self->last_degree[p_in] == 0\n && self->not_sample[p_in] && t_in < t_out);\n climb_out = (p_out != TSK_NULL && self->next_degree[p_out] == 0\n && self->not_sample[p_out] && t_out < t_in);\n if (climb_in) {\n ret = haplotype_extender_add_or_extend_edge(self, p_in, child, left, right);\n if (ret != 0) {\n goto out;\n }\n child = p_in;\n p_in = self->parent_in[p_in];\n t_in = (p_in == TSK_NULL) ? INFINITY : nodes_time[p_in];\n } else if (climb_out) {\n ret = haplotype_extender_add_or_extend_edge(self, p_out, child, left, right);\n if (ret != 0) {\n goto out;\n }\n child = p_out;\n p_out = self->parent_out[p_out];\n t_out = (p_out == TSK_NULL) ? INFINITY : nodes_time[p_out];\n } else {\n break;\n }\n }\n tsk_bug_assert(p_out == p_in);\n ret = haplotype_extender_add_or_extend_edge(self, p_out, child, left, right);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int\nhaplotype_extender_extend_paths(haplotype_extender_t *self)\n{\n int ret = 0;\n bool valid;\n double left, right;\n float ne, max_new_edges, next_max_new_edges;\n tsk_tree_position_t tree_pos;\n edge_list_t *ex_in;\n tsk_id_t e_in, c, e;\n tsk_size_t num_edges;\n tsk_bool_t *keep = NULL;\n\n tsk_memset(&tree_pos, 0, sizeof(tree_pos));\n ret = tsk_tree_position_init(&tree_pos, self->ts, 0);\n if (ret != 0) {\n goto out;\n }\n\n if (self->direction == TSK_DIR_FORWARD) {\n valid = tsk_tree_position_next(&tree_pos);\n } else {\n valid = tsk_tree_position_prev(&tree_pos);\n }\n\n while (valid) {\n left = tree_pos.interval.left;\n right = tree_pos.interval.right;\n ret = haplotype_extender_next_tree(self, &tree_pos);\n if (ret != 0) {\n goto out;\n }\n max_new_edges = 0;\n next_max_new_edges = INFINITY;\n while (max_new_edges < INFINITY) {\n for (ex_in = self->edges_in_head; ex_in != NULL; ex_in = ex_in->next) {\n e_in = ex_in->edge;\n c = self->edges->child[e_in];\n if (self->last_degree[c] > 0) {\n ne = haplotype_extender_mergeable(self, c);\n if (ne <= max_new_edges) {\n ret = haplotype_extender_merge_paths(self, c, left, right);\n if (ret != 0) {\n goto out;\n }\n } else {\n next_max_new_edges = TSK_MIN(ne, next_max_new_edges);\n }\n }\n }\n max_new_edges = next_max_new_edges;\n next_max_new_edges = INFINITY;\n }\n if (self->direction == TSK_DIR_FORWARD) {\n valid = tsk_tree_position_next(&tree_pos);\n } else {\n valid = tsk_tree_position_prev(&tree_pos);\n }\n }\n /* Get rid of adjacent, identical edges */\n /* note: we need to calloc this here instead of at the start\n * because we don't know how big it will need to be until now */\n num_edges = self->edges->num_rows;\n keep = tsk_calloc(num_edges, sizeof(*keep));\n if (keep == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n for (e = 0; e < (tsk_id_t) num_edges - 1; e++) {\n if (self->edges->parent[e] == self->edges->parent[e + 1]\n && self->edges->child[e] == self->edges->child[e + 1]\n && self->edges->right[e] == self->edges->left[e + 1]) {\n self->edges->right[e] = self->edges->right[e + 1];\n self->edges->left[e + 1] = self->edges->right[e + 1];\n }\n }\n for (e = 0; e < (tsk_id_t) num_edges; e++) {\n keep[e] = self->edges->left[e] < self->edges->right[e];\n }\n ret = tsk_edge_table_keep_rows(self->edges, keep, 0, NULL);\nout:\n tsk_tree_position_free(&tree_pos);\n tsk_safe_free(keep);\n return ret;\n}\n\nstatic int\nextend_haplotypes_iter(const tsk_treeseq_t *self, int direction, tsk_edge_table_t *edges,\n tsk_flags_t options)\n{\n int ret = 0;\n haplotype_extender_t haplotype_extender;\n tsk_memset(&haplotype_extender, 0, sizeof(haplotype_extender));\n ret = haplotype_extender_init(&haplotype_extender, self, direction, edges);\n if (ret != 0) {\n goto out;\n }\n\n ret = haplotype_extender_extend_paths(&haplotype_extender);\n if (ret != 0) {\n goto out;\n }\n\n if (!!(options & TSK_DEBUG)) {\n haplotype_extender_print_state(&haplotype_extender, tsk_get_debug_stream());\n }\n\nout:\n haplotype_extender_free(&haplotype_extender);\n return ret;\n}\n\nint TSK_WARN_UNUSED\ntsk_treeseq_extend_haplotypes(\n const tsk_treeseq_t *self, int max_iter, tsk_flags_t options, tsk_treeseq_t *output)\n{\n int ret = 0;\n tsk_table_collection_t tables;\n tsk_treeseq_t ts;\n int iter, j;\n tsk_size_t last_num_edges;\n tsk_bookmark_t sort_start;\n const int direction[] = { TSK_DIR_FORWARD, TSK_DIR_REVERSE };\n\n tsk_memset(&tables, 0, sizeof(tables));\n tsk_memset(&ts, 0, sizeof(ts));\n tsk_memset(output, 0, sizeof(*output));\n\n if (max_iter <= 0) {\n ret = tsk_trace_error(TSK_ERR_EXTEND_EDGES_BAD_MAXITER);\n goto out;\n }\n if (tsk_treeseq_get_num_migrations(self) != 0) {\n ret = tsk_trace_error(TSK_ERR_MIGRATIONS_NOT_SUPPORTED);\n goto out;\n }\n\n /* Note: there is a fair bit of copying of table data in this implementation\n * currently, as we create a new tree sequence for each iteration, which\n * takes a full copy of the input tables. We could streamline this by\n * adding a flag to treeseq_init which says \"steal a reference to these\n * tables and *don't* free them at the end\". Then, we would only need\n * one copy of the full tables, and could pass in a standalone edge\n * table to use for in-place updating.\n */\n ret = tsk_table_collection_copy(self->tables, &tables, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_mutation_table_clear(&tables.mutations);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_init(&ts, &tables, 0);\n if (ret != 0) {\n goto out;\n }\n\n last_num_edges = tsk_treeseq_get_num_edges(&ts);\n for (iter = 0; iter < max_iter; iter++) {\n for (j = 0; j < 2; j++) {\n ret = extend_haplotypes_iter(&ts, direction[j], &tables.edges, options);\n if (ret != 0) {\n goto out;\n }\n /* We're done with the current ts now */\n tsk_treeseq_free(&ts);\n /* no need to sort sites and mutations */\n memset(&sort_start, 0, sizeof(sort_start));\n sort_start.sites = tables.sites.num_rows;\n sort_start.mutations = tables.mutations.num_rows;\n ret = tsk_table_collection_sort(&tables, &sort_start, 0);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n if (ret != 0) {\n goto out;\n }\n }\n if (last_num_edges == tsk_treeseq_get_num_edges(&ts)) {\n break;\n }\n last_num_edges = tsk_treeseq_get_num_edges(&ts);\n }\n\n /* Remap mutation nodes */\n ret = tsk_mutation_table_copy(\n &self->tables->mutations, &tables.mutations, TSK_NO_INIT);\n if (ret != 0) {\n goto out;\n }\n /* Note: to allow migrations we'd also have to do this same operation\n * on the migration nodes; however it's a can of worms because the interval\n * covering the migration might no longer make sense. */\n ret = tsk_treeseq_slide_mutation_nodes_up(&ts, &tables.mutations);\n if (ret != 0) {\n goto out;\n }\n tsk_treeseq_free(&ts);\n ret = tsk_treeseq_init(&ts, &tables, TSK_TS_INIT_BUILD_INDEXES);\n if (ret != 0) {\n goto out;\n }\n\n /* Hand ownership of the tree sequence to the calling code */\n tsk_memcpy(output, &ts, sizeof(ts));\n tsk_memset(&ts, 0, sizeof(*output));\nout:\n tsk_treeseq_free(&ts);\n tsk_table_collection_free(&tables);\n return ret;\n}\n\n/* ======================================================== *\n * Pair coalescence\n * ======================================================== */\n\nstatic int\ncheck_node_bin_map(\n const tsk_size_t num_nodes, const tsk_size_t num_bins, const tsk_id_t *node_bin_map)\n{\n int ret = 0;\n tsk_id_t max_index, index;\n tsk_size_t i;\n\n max_index = TSK_NULL;\n for (i = 0; i < num_nodes; i++) {\n index = node_bin_map[i];\n if (index < TSK_NULL) {\n ret = tsk_trace_error(TSK_ERR_BAD_NODE_BIN_MAP);\n goto out;\n }\n if (index > max_index) {\n max_index = index;\n }\n }\n if (num_bins < 1 || (tsk_id_t) num_bins < max_index + 1) {\n ret = tsk_trace_error(TSK_ERR_BAD_NODE_BIN_MAP_DIM);\n goto out;\n }\nout:\n return ret;\n}\n\nstatic inline void\nTRANSPOSE_2D(tsk_size_t rows, tsk_size_t cols, const double *source, double *dest)\n{\n tsk_size_t i, j;\n for (i = 0; i < rows; ++i) {\n for (j = 0; j < cols; ++j) {\n dest[j * rows + i] = source[i * cols + j];\n }\n }\n}\n\nstatic inline void\npair_coalescence_count(tsk_size_t num_set_indexes, const tsk_id_t *set_indexes,\n tsk_size_t num_sample_sets, const double *parent_count, const double *child_count,\n const double *parent_state, const double *inside, double *outside, double *result)\n{\n tsk_size_t i;\n tsk_id_t j, k;\n for (i = 0; i < num_sample_sets; i++) {\n outside[i] = parent_count[i] - child_count[i] - parent_state[i];\n }\n for (i = 0; i < num_set_indexes; i++) {\n j = set_indexes[2 * i];\n k = set_indexes[2 * i + 1];\n result[i] = outside[j] * inside[k];\n if (j != k) {\n result[i] += outside[k] * inside[j];\n }\n }\n}\n\nint\ntsk_treeseq_pair_coalescence_stat(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_set_indexes, const tsk_id_t *set_indexes, tsk_size_t num_windows,\n const double *windows, tsk_size_t num_bins, const tsk_id_t *node_bin_map,\n pair_coalescence_stat_func_t *summary_func, tsk_size_t summary_func_dim,\n void *summary_func_args, tsk_flags_t options, double *result)\n{\n int ret = 0;\n double left, right, remaining_span, missing_span, window_span, denominator, x, t;\n tsk_id_t e, p, c, u, v, w, i, j;\n tsk_size_t num_samples, num_edges;\n tsk_tree_position_t tree_pos;\n const tsk_table_collection_t *tables = self->tables;\n const tsk_size_t num_nodes = tables->nodes.num_rows;\n const double *restrict nodes_time = self->tables->nodes.time;\n const double sequence_length = tables->sequence_length;\n const tsk_size_t num_outputs = summary_func_dim;\n\n /* buffers */\n bool *visited = NULL;\n tsk_id_t *nodes_sample_set = NULL;\n tsk_id_t *nodes_parent = NULL;\n double *coalescing_pairs = NULL;\n double *coalescence_time = NULL;\n double *nodes_sample = NULL;\n double *sample_count = NULL;\n double *bin_weight = NULL;\n double *bin_values = NULL;\n double *pair_count = NULL;\n double *total_pair = NULL;\n double *outside = NULL;\n\n /* row pointers */\n double *inside = NULL;\n double *weight = NULL;\n double *values = NULL;\n double *output = NULL;\n double *above = NULL;\n double *below = NULL;\n double *state = NULL;\n double *pairs = NULL;\n double *times = NULL;\n\n tsk_memset(&tree_pos, 0, sizeof(tree_pos));\n\n /* check inputs */\n ret = tsk_treeseq_check_windows(self, num_windows, windows, TSK_REQUIRE_FULL_SPAN);\n if (ret != 0) {\n goto out;\n }\n ret = check_set_indexes(num_sample_sets, 2 * num_set_indexes, set_indexes);\n if (ret != 0) {\n goto out;\n }\n ret = tsk_treeseq_check_sample_sets(\n self, num_sample_sets, sample_set_sizes, sample_sets);\n if (ret != 0) {\n goto out;\n }\n ret = check_node_bin_map(num_nodes, num_bins, node_bin_map);\n if (ret != 0) {\n goto out;\n }\n\n /* map nodes to sample sets */\n nodes_sample_set = tsk_malloc(num_nodes * sizeof(*nodes_sample_set));\n if (nodes_sample_set == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n ret = get_sample_set_index_map(self, num_sample_sets, sample_set_sizes, sample_sets,\n &num_samples, nodes_sample_set);\n if (ret != 0) {\n goto out;\n }\n\n visited = tsk_malloc(num_nodes * sizeof(*visited));\n outside = tsk_malloc(num_sample_sets * sizeof(*outside));\n nodes_parent = tsk_malloc(num_nodes * sizeof(*nodes_parent));\n nodes_sample = tsk_calloc(num_nodes * num_sample_sets, sizeof(*nodes_sample));\n sample_count = tsk_malloc(num_nodes * num_sample_sets * sizeof(*sample_count));\n coalescing_pairs = tsk_calloc(num_bins * num_set_indexes, sizeof(*coalescing_pairs));\n coalescence_time = tsk_calloc(num_bins * num_set_indexes, sizeof(*coalescence_time));\n bin_weight = tsk_malloc(num_bins * num_set_indexes * sizeof(*bin_weight));\n bin_values = tsk_malloc(num_bins * num_set_indexes * sizeof(*bin_values));\n pair_count = tsk_malloc(num_set_indexes * sizeof(*pair_count));\n total_pair = tsk_malloc(num_set_indexes * sizeof(*total_pair));\n if (nodes_parent == NULL || nodes_sample == NULL || sample_count == NULL\n || coalescing_pairs == NULL || bin_weight == NULL || bin_values == NULL\n || outside == NULL || pair_count == NULL || visited == NULL\n || total_pair == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n for (i = 0; i < (tsk_id_t) num_set_indexes; i++) {\n u = set_indexes[2 * i];\n v = set_indexes[2 * i + 1];\n total_pair[i] = (double) sample_set_sizes[u] * (double) sample_set_sizes[v];\n if (u == v) {\n total_pair[i] -= (double) sample_set_sizes[v];\n total_pair[i] /= 2;\n }\n }\n\n /* initialize internal state */\n for (c = 0; c < (tsk_id_t) num_nodes; c++) {\n i = nodes_sample_set[c];\n if (i != TSK_NULL) {\n state = GET_2D_ROW(nodes_sample, num_sample_sets, c);\n state[i] = 1.0;\n }\n nodes_parent[c] = TSK_NULL;\n visited[c] = false;\n }\n tsk_memcpy(\n sample_count, nodes_sample, num_nodes * num_sample_sets * sizeof(*sample_count));\n\n ret = tsk_tree_position_init(&tree_pos, self, 0);\n if (ret != 0) {\n goto out;\n }\n\n num_edges = 0;\n missing_span = 0.0;\n w = 0;\n while (true) {\n tsk_tree_position_next(&tree_pos);\n if (tree_pos.index == TSK_NULL) {\n break;\n }\n\n left = tree_pos.interval.left;\n right = tree_pos.interval.right;\n remaining_span = sequence_length - left;\n\n for (u = tree_pos.out.start; u != tree_pos.out.stop; u++) {\n e = tree_pos.out.order[u];\n p = tables->edges.parent[e];\n c = tables->edges.child[e];\n nodes_parent[c] = TSK_NULL;\n inside = GET_2D_ROW(sample_count, num_sample_sets, c);\n while (p != TSK_NULL) { /* downdate statistic */\n v = node_bin_map[p];\n t = nodes_time[p];\n if (v != TSK_NULL) {\n above = GET_2D_ROW(sample_count, num_sample_sets, p);\n below = GET_2D_ROW(sample_count, num_sample_sets, c);\n state = GET_2D_ROW(nodes_sample, num_sample_sets, p);\n pairs = GET_2D_ROW(coalescing_pairs, num_set_indexes, v);\n times = GET_2D_ROW(coalescence_time, num_set_indexes, v);\n pair_coalescence_count(num_set_indexes, set_indexes, num_sample_sets,\n above, below, state, inside, outside, pair_count);\n for (i = 0; i < (tsk_id_t) num_set_indexes; i++) {\n x = pair_count[i] * remaining_span;\n pairs[i] -= x;\n times[i] -= t * x;\n }\n }\n c = p;\n p = nodes_parent[c];\n }\n p = tables->edges.parent[e];\n while (p != TSK_NULL) { /* downdate state */\n above = GET_2D_ROW(sample_count, num_sample_sets, p);\n for (i = 0; i < (tsk_id_t) num_sample_sets; i++) {\n above[i] -= inside[i];\n }\n p = nodes_parent[p];\n }\n num_edges -= 1;\n }\n\n for (u = tree_pos.in.start; u != tree_pos.in.stop; u++) {\n e = tree_pos.in.order[u];\n p = tables->edges.parent[e];\n c = tables->edges.child[e];\n nodes_parent[c] = p;\n inside = GET_2D_ROW(sample_count, num_sample_sets, c);\n while (p != TSK_NULL) { /* update state */\n above = GET_2D_ROW(sample_count, num_sample_sets, p);\n for (i = 0; i < (tsk_id_t) num_sample_sets; i++) {\n above[i] += inside[i];\n }\n p = nodes_parent[p];\n }\n p = tables->edges.parent[e];\n while (p != TSK_NULL) { /* update statistic */\n v = node_bin_map[p];\n t = nodes_time[p];\n if (v != TSK_NULL) {\n above = GET_2D_ROW(sample_count, num_sample_sets, p);\n below = GET_2D_ROW(sample_count, num_sample_sets, c);\n state = GET_2D_ROW(nodes_sample, num_sample_sets, p);\n pairs = GET_2D_ROW(coalescing_pairs, num_set_indexes, v);\n times = GET_2D_ROW(coalescence_time, num_set_indexes, v);\n pair_coalescence_count(num_set_indexes, set_indexes, num_sample_sets,\n above, below, state, inside, outside, pair_count);\n for (i = 0; i < (tsk_id_t) num_set_indexes; i++) {\n x = pair_count[i] * remaining_span;\n pairs[i] += x;\n times[i] += t * x;\n }\n }\n c = p;\n p = nodes_parent[c];\n }\n num_edges += 1;\n }\n\n if (num_edges == 0) {\n missing_span += right - left;\n }\n\n /* flush windows */\n while (w < (tsk_id_t) num_windows && windows[w + 1] <= right) {\n TRANSPOSE_2D(num_bins, num_set_indexes, coalescing_pairs, bin_weight);\n TRANSPOSE_2D(num_bins, num_set_indexes, coalescence_time, bin_values);\n tsk_memset(coalescing_pairs, 0,\n num_bins * num_set_indexes * sizeof(*coalescing_pairs));\n tsk_memset(coalescence_time, 0,\n num_bins * num_set_indexes * sizeof(*coalescence_time));\n remaining_span = sequence_length - windows[w + 1];\n for (j = 0; j < (tsk_id_t) num_samples; j++) { /* truncate at tree */\n c = sample_sets[j];\n p = nodes_parent[c];\n while (!visited[c] && p != TSK_NULL) {\n v = node_bin_map[p];\n t = nodes_time[p];\n if (v != TSK_NULL) {\n above = GET_2D_ROW(sample_count, num_sample_sets, p);\n below = GET_2D_ROW(sample_count, num_sample_sets, c);\n state = GET_2D_ROW(nodes_sample, num_sample_sets, p);\n pairs = GET_2D_ROW(coalescing_pairs, num_set_indexes, v);\n times = GET_2D_ROW(coalescence_time, num_set_indexes, v);\n pair_coalescence_count(num_set_indexes, set_indexes,\n num_sample_sets, above, below, state, below, outside,\n pair_count);\n for (i = 0; i < (tsk_id_t) num_set_indexes; i++) {\n weight = GET_2D_ROW(bin_weight, num_bins, i);\n values = GET_2D_ROW(bin_values, num_bins, i);\n x = pair_count[i] * remaining_span / 2;\n pairs[i] += x;\n times[i] += t * x;\n weight[v] -= x;\n values[v] -= t * x;\n }\n }\n visited[c] = true;\n c = p;\n p = nodes_parent[c];\n }\n }\n for (j = 0; j < (tsk_id_t) num_samples; j++) { /* reset tree */\n c = sample_sets[j];\n p = nodes_parent[c];\n while (visited[c] && p != TSK_NULL) {\n visited[c] = false;\n c = p;\n p = nodes_parent[c];\n }\n }\n for (i = 0; i < (tsk_id_t) num_set_indexes; i++) { /* normalise values */\n weight = GET_2D_ROW(bin_weight, num_bins, i);\n values = GET_2D_ROW(bin_values, num_bins, i);\n for (v = 0; v < (tsk_id_t) num_bins; v++) {\n values[v] /= weight[v];\n }\n }\n /* normalise weights */\n if (options & (TSK_STAT_SPAN_NORMALISE | TSK_STAT_PAIR_NORMALISE)) {\n window_span = windows[w + 1] - windows[w] - missing_span;\n missing_span = 0.0;\n if (num_edges == 0) {\n /* missing interval, so remove overcounted missing span */\n remaining_span = right - windows[w + 1];\n window_span += remaining_span;\n missing_span += remaining_span;\n }\n for (i = 0; i < (tsk_id_t) num_set_indexes; i++) {\n denominator = 1.0;\n if (options & TSK_STAT_SPAN_NORMALISE) {\n denominator *= window_span;\n }\n if (options & TSK_STAT_PAIR_NORMALISE) {\n denominator *= total_pair[i];\n }\n weight = GET_2D_ROW(bin_weight, num_bins, i);\n for (v = 0; v < (tsk_id_t) num_bins; v++) {\n weight[v] *= denominator == 0.0 ? 0.0 : 1 / denominator;\n }\n }\n }\n for (i = 0; i < (tsk_id_t) num_set_indexes; i++) { /* summarise bins */\n weight = GET_2D_ROW(bin_weight, num_bins, i);\n values = GET_2D_ROW(bin_values, num_bins, i);\n output = GET_3D_ROW(\n result, num_set_indexes, num_outputs, (tsk_size_t) w, i);\n ret = summary_func(\n num_bins, weight, values, num_outputs, output, summary_func_args);\n if (ret != 0) {\n goto out;\n }\n };\n w += 1;\n }\n }\nout:\n tsk_tree_position_free(&tree_pos);\n tsk_safe_free(nodes_sample_set);\n tsk_safe_free(coalescing_pairs);\n tsk_safe_free(coalescence_time);\n tsk_safe_free(nodes_parent);\n tsk_safe_free(nodes_sample);\n tsk_safe_free(sample_count);\n tsk_safe_free(bin_weight);\n tsk_safe_free(bin_values);\n tsk_safe_free(pair_count);\n tsk_safe_free(total_pair);\n tsk_safe_free(visited);\n tsk_safe_free(outside);\n return ret;\n}\n\nstatic int\npair_coalescence_weights(tsk_size_t TSK_UNUSED(input_dim), const double *weight,\n const double *TSK_UNUSED(values), tsk_size_t output_dim, double *output,\n void *TSK_UNUSED(params))\n{\n int ret = 0;\n tsk_memcpy(output, weight, output_dim * sizeof(*output));\n return ret;\n}\n\nint\ntsk_treeseq_pair_coalescence_counts(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_set_indexes, const tsk_id_t *set_indexes,\n tsk_size_t num_windows, const double *windows, tsk_size_t num_bins,\n const tsk_id_t *node_bin_map, tsk_flags_t options, double *result)\n{\n return tsk_treeseq_pair_coalescence_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_set_indexes, set_indexes, num_windows, windows, num_bins,\n node_bin_map, pair_coalescence_weights, num_bins, NULL, options, result);\n}\n\nstatic int\npair_coalescence_quantiles(tsk_size_t input_dim, const double *weight,\n const double *values, tsk_size_t output_dim, double *output, void *params)\n{\n int ret = 0;\n double coalesced, timepoint;\n double *quantiles = (double *) params;\n tsk_size_t i, j;\n j = 0;\n coalesced = 0.0;\n timepoint = TSK_UNKNOWN_TIME;\n for (i = 0; i < output_dim; i++) {\n output[i] = NAN;\n }\n for (i = 0; i < input_dim; i++) {\n if (weight[i] > 0) {\n coalesced += weight[i];\n timepoint = values[i];\n while (j < output_dim && quantiles[j] <= coalesced) {\n output[j] = timepoint;\n j += 1;\n }\n }\n }\n if (quantiles[output_dim - 1] == 1.0) {\n output[output_dim - 1] = timepoint;\n }\n return ret;\n}\n\nstatic int\ncheck_quantiles(const tsk_size_t num_quantiles, const double *quantiles)\n{\n int ret = 0;\n tsk_size_t i;\n double last = -INFINITY;\n for (i = 0; i < num_quantiles; i++) {\n if (quantiles[i] <= last || quantiles[i] < 0.0 || quantiles[i] > 1.0) {\n ret = tsk_trace_error(TSK_ERR_BAD_QUANTILES);\n goto out;\n }\n last = quantiles[i];\n }\nout:\n return ret;\n}\n\nstatic int\ncheck_sorted_node_bin_map(\n const tsk_treeseq_t *self, tsk_size_t num_bins, const tsk_id_t *node_bin_map)\n{\n int ret = 0;\n tsk_size_t num_nodes = self->tables->nodes.num_rows;\n const double *nodes_time = self->tables->nodes.time;\n double last;\n tsk_id_t i, j;\n double *min_time = tsk_malloc(num_bins * sizeof(*min_time));\n double *max_time = tsk_malloc(num_bins * sizeof(*max_time));\n if (min_time == NULL || max_time == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n for (j = 0; j < (tsk_id_t) num_bins; j++) {\n min_time[j] = TSK_UNKNOWN_TIME;\n max_time[j] = TSK_UNKNOWN_TIME;\n }\n for (i = 0; i < (tsk_id_t) num_nodes; i++) {\n j = node_bin_map[i];\n if (j < 0 || j >= (tsk_id_t) num_bins) {\n continue;\n }\n if (tsk_is_unknown_time(max_time[j]) || nodes_time[i] > max_time[j]) {\n max_time[j] = nodes_time[i];\n }\n if (tsk_is_unknown_time(min_time[j]) || nodes_time[i] < min_time[j]) {\n min_time[j] = nodes_time[i];\n }\n }\n last = -INFINITY;\n for (j = 0; j < (tsk_id_t) num_bins; j++) {\n if (tsk_is_unknown_time(min_time[j])) {\n continue;\n }\n if (min_time[j] < last) {\n ret = tsk_trace_error(TSK_ERR_UNSORTED_TIMES);\n goto out;\n } else {\n last = max_time[j];\n }\n }\nout:\n tsk_safe_free(min_time);\n tsk_safe_free(max_time);\n return ret;\n}\n\nint\ntsk_treeseq_pair_coalescence_quantiles(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_set_indexes, const tsk_id_t *set_indexes,\n tsk_size_t num_windows, const double *windows, tsk_size_t num_bins,\n const tsk_id_t *node_bin_map, tsk_size_t num_quantiles, double *quantiles,\n tsk_flags_t options, double *result)\n{\n int ret = 0;\n void *params = (void *) quantiles;\n ret = check_quantiles(num_quantiles, quantiles);\n if (ret != 0) {\n goto out;\n }\n ret = check_sorted_node_bin_map(self, num_bins, node_bin_map);\n if (ret != 0) {\n goto out;\n }\n options |= TSK_STAT_SPAN_NORMALISE | TSK_STAT_PAIR_NORMALISE;\n ret = tsk_treeseq_pair_coalescence_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_set_indexes, set_indexes, num_windows, windows, num_bins,\n node_bin_map, pair_coalescence_quantiles, num_quantiles, params, options,\n result);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\nstatic int\npair_coalescence_rates(tsk_size_t input_dim, const double *weight, const double *values,\n tsk_size_t output_dim, double *output, void *params)\n{\n int ret = 0;\n double coalesced, rate, waiting_time, a, b;\n double *time_windows = (double *) params;\n tsk_id_t i, j;\n tsk_bug_assert(input_dim == output_dim);\n for (j = (tsk_id_t) output_dim; j > 0; j--) { /* find last window with data */\n if (weight[j - 1] == 0) {\n output[j - 1] = NAN; /* TODO: should fill value be zero instead? */\n } else {\n break;\n }\n }\n coalesced = 0.0;\n for (i = 0; i < j; i++) {\n a = time_windows[i];\n b = time_windows[i + 1];\n if (i + 1 == j) {\n waiting_time = values[i] < a ? 0.0 : values[i] - a;\n rate = 1 / waiting_time;\n } else {\n rate = log(1 - weight[i] / (1 - coalesced)) / (a - b);\n }\n // avoid tiny negative values from fp error\n output[i] = rate > 0 ? rate : 0;\n coalesced += weight[i];\n }\n return ret;\n}\n\nstatic int\ncheck_coalescence_rate_time_windows(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_time_windows,\n const tsk_id_t *node_time_window, const double *time_windows)\n{\n int ret = 0;\n double timepoint;\n const double *nodes_time = self->tables->nodes.time;\n tsk_size_t num_nodes = self->tables->nodes.num_rows;\n tsk_id_t i, j, k;\n tsk_id_t n;\n if (num_time_windows == 0) {\n ret = tsk_trace_error(TSK_ERR_BAD_TIME_WINDOWS_DIM);\n goto out;\n }\n /* time windows are sorted */\n timepoint = time_windows[0];\n for (i = 0; i < (tsk_id_t) num_time_windows; i++) {\n if (time_windows[i + 1] <= timepoint) {\n ret = tsk_trace_error(TSK_ERR_BAD_TIME_WINDOWS);\n goto out;\n }\n timepoint = time_windows[i + 1];\n }\n if (timepoint != INFINITY) {\n ret = tsk_trace_error(TSK_ERR_BAD_TIME_WINDOWS_END);\n goto out;\n }\n /* all sample times align with start of first time window */\n k = 0;\n for (i = 0; i < (tsk_id_t) num_sample_sets; i++) {\n for (j = 0; j < (tsk_id_t) sample_set_sizes[i]; j++) {\n n = sample_sets[k++];\n if (nodes_time[n] != time_windows[0]) {\n ret = tsk_trace_error(TSK_ERR_BAD_SAMPLE_PAIR_TIMES);\n goto out;\n }\n }\n }\n /* nodes are correctly assigned to time windows */\n for (i = 0; i < (tsk_id_t) num_nodes; i++) {\n j = node_time_window[i];\n if (j < 0) {\n continue;\n }\n if (j >= (tsk_id_t) num_time_windows) {\n ret = tsk_trace_error(TSK_ERR_BAD_NODE_BIN_MAP_DIM);\n goto out;\n }\n if (nodes_time[i] < time_windows[j] || nodes_time[i] >= time_windows[j + 1]) {\n ret = tsk_trace_error(TSK_ERR_BAD_NODE_TIME_WINDOW);\n goto out;\n }\n }\nout:\n return ret;\n}\n\nint\ntsk_treeseq_pair_coalescence_rates(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_set_indexes, const tsk_id_t *set_indexes, tsk_size_t num_windows,\n const double *windows, tsk_size_t num_time_windows, const tsk_id_t *node_time_window,\n double *time_windows, tsk_flags_t options, double *result)\n{\n int ret = 0;\n void *params = (void *) time_windows;\n ret = check_coalescence_rate_time_windows(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_time_windows, node_time_window, time_windows);\n if (ret != 0) {\n goto out;\n }\n options |= TSK_STAT_SPAN_NORMALISE | TSK_STAT_PAIR_NORMALISE;\n ret = tsk_treeseq_pair_coalescence_stat(self, num_sample_sets, sample_set_sizes,\n sample_sets, num_set_indexes, set_indexes, num_windows, windows,\n num_time_windows, node_time_window, pair_coalescence_rates, num_time_windows,\n params, options, result);\n if (ret != 0) {\n goto out;\n }\nout:\n return ret;\n}\n\n/* ======================================================== *\n * Relatedness matrix-vector product\n * ======================================================== */\n\ntypedef struct {\n const tsk_treeseq_t *ts;\n tsk_size_t num_weights;\n const double *weights;\n tsk_size_t num_windows;\n const double *windows;\n tsk_size_t num_focal_nodes;\n const tsk_id_t *focal_nodes;\n tsk_flags_t options;\n double *result;\n tsk_tree_position_t tree_pos;\n double position;\n tsk_size_t num_nodes;\n tsk_id_t *parent;\n double *x;\n double *w;\n double *v;\n} tsk_matvec_calculator_t;\n\nstatic void\ntsk_matvec_calculator_print_state(const tsk_matvec_calculator_t *self, FILE *out)\n{\n tsk_id_t j;\n tsk_size_t num_samples = tsk_treeseq_get_num_samples(self->ts);\n\n fprintf(out, \"Matvec state:\\n\");\n fprintf(out, \"options = %d\\n\", self->options);\n fprintf(out, \"position = %f\\n\", self->position);\n fprintf(out, \"focal nodes = %lld: [\", (long long) self->num_focal_nodes);\n fprintf(out, \"tree_pos:\\n\");\n tsk_tree_position_print_state(&self->tree_pos, out);\n fprintf(out, \"samples = %lld: [\", (long long) num_samples);\n fprintf(out, \"]\\n\");\n fprintf(out, \"node\\tparent\\tx\\tv\\tw\");\n fprintf(out, \"\\n\");\n\n for (j = 0; j < (tsk_id_t) self->num_nodes; j++) {\n fprintf(out, \"%lld\\t\", (long long) j);\n fprintf(out, \"%lld\\t%g\\t%g\\t%g\\n\", (long long) self->parent[j], self->x[j],\n self->v[j], self->w[j]);\n }\n}\n\nstatic int\ntsk_matvec_calculator_init(tsk_matvec_calculator_t *self, const tsk_treeseq_t *ts,\n tsk_size_t num_weights, const double *weights, tsk_size_t num_windows,\n const double *windows, tsk_size_t num_focal_nodes, const tsk_id_t *focal_nodes,\n tsk_flags_t options, double *result)\n{\n int ret = 0;\n tsk_size_t num_samples = tsk_treeseq_get_num_samples(ts);\n const tsk_size_t num_nodes = ts->tables->nodes.num_rows;\n const double *row;\n double *new_row;\n tsk_size_t k;\n tsk_id_t index, u, j;\n double *weight_means = tsk_malloc(num_weights * sizeof(*weight_means));\n const tsk_size_t num_trees = ts->num_trees;\n const double *restrict breakpoints = ts->breakpoints;\n\n self->ts = ts;\n self->num_weights = num_weights;\n self->weights = weights;\n self->num_windows = num_windows;\n self->windows = windows;\n self->num_focal_nodes = num_focal_nodes;\n self->focal_nodes = focal_nodes;\n self->options = options;\n self->result = result;\n self->num_nodes = num_nodes;\n self->position = windows[0];\n\n self->parent = tsk_malloc(num_nodes * sizeof(*self->parent));\n self->x = tsk_calloc(num_nodes, sizeof(*self->x));\n self->v = tsk_calloc(num_nodes * num_weights, sizeof(*self->v));\n self->w = tsk_calloc(num_nodes * num_weights, sizeof(*self->w));\n\n if (self->parent == NULL || self->x == NULL || self->w == NULL || self->v == NULL\n || weight_means == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n tsk_memset(result, 0, num_windows * num_focal_nodes * num_weights * sizeof(*result));\n tsk_memset(self->parent, TSK_NULL, num_nodes * sizeof(*self->parent));\n\n for (j = 0; j < (tsk_id_t) num_focal_nodes; j++) {\n if (focal_nodes[j] < 0 || (tsk_size_t) focal_nodes[j] >= num_nodes) {\n ret = tsk_trace_error(TSK_ERR_NODE_OUT_OF_BOUNDS);\n goto out;\n }\n }\n\n ret = tsk_tree_position_init(&self->tree_pos, ts, 0);\n if (ret != 0) {\n goto out;\n }\n /* seek to the first window */\n index = (tsk_id_t) tsk_search_sorted(breakpoints, num_trees + 1, windows[0]);\n if (breakpoints[index] > windows[0]) {\n index--;\n }\n ret = tsk_tree_position_seek_forward(&self->tree_pos, index);\n if (ret != 0) {\n goto out;\n }\n\n for (k = 0; k < num_weights; k++) {\n weight_means[k] = 0.0;\n }\n /* centre the input */\n if (!(options & TSK_STAT_NONCENTRED)) {\n for (j = 0; j < (tsk_id_t) num_samples; j++) {\n row = GET_2D_ROW(weights, num_weights, j);\n for (k = 0; k < num_weights; k++) {\n weight_means[k] += row[k];\n }\n }\n for (k = 0; k < num_weights; k++) {\n weight_means[k] /= (double) num_samples;\n }\n }\n\n /* set the initial state */\n for (j = 0; j < (tsk_id_t) num_samples; j++) {\n u = ts->samples[j];\n row = GET_2D_ROW(weights, num_weights, j);\n new_row = GET_2D_ROW(self->w, num_weights, u);\n for (k = 0; k < num_weights; k++) {\n new_row[k] = row[k] - weight_means[k];\n }\n }\nout:\n tsk_safe_free(weight_means);\n return ret;\n}\n\nstatic int\ntsk_matvec_calculator_free(tsk_matvec_calculator_t *self)\n{\n tsk_safe_free(self->parent);\n tsk_safe_free(self->x);\n tsk_safe_free(self->w);\n tsk_safe_free(self->v);\n tsk_tree_position_free(&self->tree_pos);\n\n /* Make this safe for multiple free calls */\n memset(self, 0, sizeof(*self));\n return 0;\n}\n\nstatic inline void\ntsk_matvec_calculator_add_z(tsk_id_t u, tsk_id_t p, const double position,\n double *restrict x, const tsk_size_t num_weights, double *restrict w,\n double *restrict v, const double *restrict nodes_time)\n{\n double t, span;\n tsk_size_t j;\n double *restrict v_row, *restrict w_row;\n\n if (p != TSK_NULL) {\n t = nodes_time[p] - nodes_time[u];\n span = position - x[u];\n // do this: self->v[u] += t * span * self->w[u];\n w_row = GET_2D_ROW(w, num_weights, u);\n v_row = GET_2D_ROW(v, num_weights, u);\n for (j = 0; j < num_weights; j++) {\n v_row[j] += t * span * w_row[j];\n }\n }\n x[u] = position;\n}\n\nstatic void\ntsk_matvec_calculator_adjust_path_up(\n tsk_matvec_calculator_t *self, tsk_id_t p, tsk_id_t c, double sign)\n{\n tsk_size_t j;\n double *p_row, *c_row;\n const tsk_id_t *restrict parent = self->parent;\n const double position = self->position;\n double *restrict x = self->x;\n const tsk_size_t num_weights = self->num_weights;\n double *restrict w = self->w;\n double *restrict v = self->v;\n const double *restrict nodes_time = self->ts->tables->nodes.time;\n\n // sign = -1 for removing edges, +1 for adding\n while (p != TSK_NULL) {\n tsk_matvec_calculator_add_z(\n p, parent[p], position, x, num_weights, w, v, nodes_time);\n // do this: self->v[c] -= sign * self->v[p];\n p_row = GET_2D_ROW(v, num_weights, p);\n c_row = GET_2D_ROW(v, num_weights, c);\n for (j = 0; j < num_weights; j++) {\n c_row[j] -= sign * p_row[j];\n }\n // do this: self->w[p] += sign * self->w[c];\n p_row = GET_2D_ROW(w, num_weights, p);\n c_row = GET_2D_ROW(w, num_weights, c);\n for (j = 0; j < num_weights; j++) {\n p_row[j] += sign * c_row[j];\n }\n p = parent[p];\n }\n}\n\nstatic void\ntsk_matvec_calculator_remove_edge(tsk_matvec_calculator_t *self, tsk_id_t p, tsk_id_t c)\n{\n tsk_id_t *parent = self->parent;\n const double position = self->position;\n double *restrict x = self->x;\n const tsk_size_t num_weights = self->num_weights;\n double *restrict w = self->w;\n double *restrict v = self->v;\n const double *restrict nodes_time = self->ts->tables->nodes.time;\n\n tsk_matvec_calculator_add_z(\n c, parent[c], position, x, num_weights, w, v, nodes_time);\n parent[c] = TSK_NULL;\n tsk_matvec_calculator_adjust_path_up(self, p, c, -1);\n}\n\nstatic void\ntsk_matvec_calculator_insert_edge(tsk_matvec_calculator_t *self, tsk_id_t p, tsk_id_t c)\n{\n tsk_id_t *parent = self->parent;\n\n tsk_matvec_calculator_adjust_path_up(self, p, c, +1);\n self->x[c] = self->position;\n parent[c] = p;\n}\n\nstatic int\ntsk_matvec_calculator_write_output(tsk_matvec_calculator_t *self, double *restrict y)\n{\n int ret = 0;\n tsk_id_t u;\n tsk_size_t j, k;\n const tsk_size_t n = self->num_focal_nodes;\n const tsk_size_t num_weights = self->num_weights;\n const double position = self->position;\n double *u_row, *out_row;\n double *out_means = tsk_malloc(num_weights * sizeof(*out_means));\n const tsk_id_t *restrict parent = self->parent;\n const double *restrict nodes_time = self->ts->tables->nodes.time;\n double *restrict x = self->x;\n double *restrict w = self->w;\n double *restrict v = self->v;\n const tsk_id_t *restrict focal_nodes = self->focal_nodes;\n\n if (out_means == NULL) {\n ret = tsk_trace_error(TSK_ERR_NO_MEMORY);\n goto out;\n }\n\n for (j = 0; j < n; j++) {\n out_row = GET_2D_ROW(y, num_weights, j);\n u = focal_nodes[j];\n while (u != TSK_NULL) {\n if (x[u] != position) {\n tsk_matvec_calculator_add_z(\n u, parent[u], position, x, num_weights, w, v, nodes_time);\n }\n u_row = GET_2D_ROW(v, num_weights, u);\n for (k = 0; k < num_weights; k++) {\n out_row[k] += u_row[k];\n }\n u = parent[u];\n }\n }\n\n if (!(self->options & TSK_STAT_NONCENTRED)) {\n for (k = 0; k < num_weights; k++) {\n out_means[k] = 0.0;\n }\n for (j = 0; j < n; j++) {\n out_row = GET_2D_ROW(y, num_weights, j);\n for (k = 0; k < num_weights; k++) {\n out_means[k] += out_row[k];\n }\n }\n for (k = 0; k < num_weights; k++) {\n out_means[k] /= (double) n;\n }\n for (j = 0; j < n; j++) {\n out_row = GET_2D_ROW(y, num_weights, j);\n for (k = 0; k < num_weights; k++) {\n out_row[k] -= out_means[k];\n }\n }\n }\n /* zero out v */\n tsk_memset(self->v, 0, self->num_nodes * num_weights * sizeof(*self->v));\nout:\n tsk_safe_free(out_means);\n return ret;\n}\n\nstatic int\ntsk_matvec_calculator_run(tsk_matvec_calculator_t *self)\n{\n int ret = 0;\n tsk_size_t j, k, m;\n tsk_id_t e, p, c;\n const tsk_size_t out_size = self->num_weights * self->num_focal_nodes;\n const tsk_size_t num_edges = self->ts->tables->edges.num_rows;\n const double *restrict edge_right = self->ts->tables->edges.right;\n const double *restrict edge_left = self->ts->tables->edges.left;\n const tsk_id_t *restrict edge_child = self->ts->tables->edges.child;\n const tsk_id_t *restrict edge_parent = self->ts->tables->edges.parent;\n const double *restrict windows = self->windows;\n double *restrict out;\n tsk_tree_position_t tree_pos = self->tree_pos;\n const tsk_id_t *restrict in_order = tree_pos.in.order;\n const tsk_id_t *restrict out_order = tree_pos.out.order;\n bool valid;\n double next_position;\n\n m = 0;\n self->position = windows[0];\n\n for (j = (tsk_size_t) tree_pos.in.start; j != (tsk_size_t) tree_pos.in.stop; j++) {\n e = in_order[j];\n tsk_bug_assert(edge_left[e] <= self->position);\n if (self->position < edge_right[e]) {\n p = edge_parent[e];\n c = edge_child[e];\n tsk_matvec_calculator_insert_edge(self, p, c);\n }\n }\n\n valid = tsk_tree_position_next(&tree_pos);\n j = (tsk_size_t) tree_pos.in.start;\n k = (tsk_size_t) tree_pos.out.start;\n while (m < self->num_windows) {\n if (valid && self->position == tree_pos.interval.left) {\n for (k = (tsk_size_t) tree_pos.out.start;\n k != (tsk_size_t) tree_pos.out.stop; k++) {\n e = out_order[k];\n p = edge_parent[e];\n c = edge_child[e];\n tsk_matvec_calculator_remove_edge(self, p, c);\n }\n for (j = (tsk_size_t) tree_pos.in.start; j != (tsk_size_t) tree_pos.in.stop;\n j++) {\n e = in_order[j];\n p = edge_parent[e];\n c = edge_child[e];\n tsk_matvec_calculator_insert_edge(self, p, c);\n }\n valid = tsk_tree_position_next(&tree_pos);\n }\n next_position = windows[m + 1];\n if (j < num_edges) {\n next_position = TSK_MIN(next_position, edge_left[in_order[j]]);\n }\n if (k < num_edges) {\n next_position = TSK_MIN(next_position, edge_right[out_order[k]]);\n }\n tsk_bug_assert(self->position < next_position);\n self->position = next_position;\n if (self->position == windows[m + 1]) {\n out = GET_2D_ROW(self->result, out_size, m);\n tsk_matvec_calculator_write_output(self, out);\n m += 1;\n }\n if (self->options & TSK_DEBUG) {\n tsk_matvec_calculator_print_state(self, tsk_get_debug_stream());\n }\n }\n if (!!(self->options & TSK_STAT_SPAN_NORMALISE)) {\n span_normalise(self->num_windows, windows, out_size, self->result);\n }\n\n /* out: */\n return ret;\n}\n\nint\ntsk_treeseq_genetic_relatedness_vector(const tsk_treeseq_t *self, tsk_size_t num_weights,\n const double *weights, tsk_size_t num_windows, const double *windows,\n tsk_size_t num_focal_nodes, const tsk_id_t *focal_nodes, double *result,\n tsk_flags_t options)\n{\n int ret = 0;\n bool stat_site = !!(options & TSK_STAT_SITE);\n bool stat_node = !!(options & TSK_STAT_NODE);\n tsk_matvec_calculator_t calc;\n\n memset(&calc, 0, sizeof(calc));\n\n if (stat_node || stat_site) {\n ret = tsk_trace_error(TSK_ERR_UNSUPPORTED_STAT_MODE);\n goto out;\n }\n ret = tsk_treeseq_check_windows(self, num_windows, windows, 0);\n if (ret != 0) {\n goto out;\n }\n\n ret = tsk_matvec_calculator_init(&calc, self, num_weights, weights, num_windows,\n windows, num_focal_nodes, focal_nodes, options, result);\n if (ret != 0) {\n goto out;\n }\n if (options & TSK_DEBUG) {\n tsk_matvec_calculator_print_state(&calc, tsk_get_debug_stream());\n }\n ret = tsk_matvec_calculator_run(&calc);\nout:\n tsk_matvec_calculator_free(&calc);\n return ret;\n}\n"
},
{
"path": "c/tskit/trees.h",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2024 Tskit Developers\n * Copyright (c) 2015-2018 University of Oxford\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n/**\n * @file trees.h\n * @brief Tskit core tree sequence operations.\n */\n#ifndef TSK_TREES_H\n#define TSK_TREES_H\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#include \n\n// clang-format off\n\n/*\n * These are both undocumented options for tsk_tree_init\n */\n#define TSK_SAMPLE_LISTS (1 << 1)\n#define TSK_NO_SAMPLE_COUNTS (1 << 2)\n\n#define TSK_STAT_SITE (1 << 0)\n#define TSK_STAT_BRANCH (1 << 1)\n#define TSK_STAT_NODE (1 << 2)\n\n/* Leave room for other stat types */\n#define TSK_STAT_POLARISED (1 << 10)\n#define TSK_STAT_SPAN_NORMALISE (1 << 11)\n#define TSK_STAT_ALLOW_TIME_UNCALIBRATED (1 << 12)\n#define TSK_STAT_PAIR_NORMALISE (1 << 13)\n#define TSK_STAT_NONCENTRED (1 << 14)\n\n/* Options for map_mutations */\n#define TSK_MM_FIXED_ANCESTRAL_STATE (1 << 0)\n\n#define TSK_DIR_FORWARD 1\n#define TSK_DIR_REVERSE -1\n\n/**\n@defgroup API_FLAGS_TS_INIT_GROUP :c:func:`tsk_treeseq_init` specific flags.\n@{\n*/\n/**\nIf specified edge indexes will be built and stored in the table collection\nwhen the tree sequence is initialised. Indexes are required for a valid\ntree sequence, and are not built by default for performance reasons.\n*/\n#define TSK_TS_INIT_BUILD_INDEXES (1 << 0)\n/**\nIf specified, mutation parents in the table collection will be overwritten\nwith those computed from the topology when the tree sequence is initialised.\n*/\n#define TSK_TS_INIT_COMPUTE_MUTATION_PARENTS (1 << 1)\n/** @} */\n\n// clang-format on\n\n/**\n@brief The tree sequence object.\n*/\ntypedef struct {\n tsk_size_t num_trees;\n tsk_size_t num_samples;\n tsk_id_t *samples;\n /* Does this tree sequence have time_units == \"uncalibrated\" */\n bool time_uncalibrated;\n /* Are all genome coordinates discrete? */\n bool discrete_genome;\n /* Are all time values discrete? */\n bool discrete_time;\n /* Min and max time in node table and mutation table */\n double min_time;\n double max_time;\n /* Breakpoints along the sequence, including 0 and L. */\n double *breakpoints;\n /* If a node is a sample, map to its index in the samples list */\n tsk_id_t *sample_index_map;\n /* Map individuals to the list of nodes that reference them */\n tsk_id_t *individual_nodes_mem;\n tsk_id_t **individual_nodes;\n tsk_size_t *individual_nodes_length;\n /* For each tree, a list of sites on that tree */\n tsk_site_t *tree_sites_mem;\n tsk_site_t **tree_sites;\n tsk_size_t *tree_sites_length;\n /* For each site, a list of mutations at that site */\n tsk_mutation_t *site_mutations_mem;\n tsk_mutation_t **site_mutations;\n tsk_size_t *site_mutations_length;\n /** @brief The table collection underlying this tree sequence, This table\n * collection must be treated as read-only, and any changes to it will\n * lead to undefined behaviour. */\n tsk_table_collection_t *tables;\n} tsk_treeseq_t;\n\ntypedef struct {\n tsk_id_t index;\n struct {\n double left;\n double right;\n } interval;\n struct {\n tsk_id_t start;\n tsk_id_t stop;\n const tsk_id_t *order;\n } in;\n struct {\n tsk_id_t start;\n tsk_id_t stop;\n const tsk_id_t *order;\n } out;\n tsk_id_t left_current_index;\n tsk_id_t right_current_index;\n int direction;\n const tsk_treeseq_t *tree_sequence;\n} tsk_tree_position_t;\n\n/**\n@brief A single tree in a tree sequence.\n\n@rst\nA ``tsk_tree_t`` object has two basic functions:\n\n1. Represent the state of a single tree in a tree sequence;\n2. Provide methods to transform this state into different trees in the sequence.\n\nThe state of a single tree in the tree sequence is represented using the\nquintuply linked encoding: please see the\n:ref:`data model ` section for details on\nhow this works. The left-to-right ordering of nodes in this encoding\nis arbitrary, and may change depending on the order in which trees are\naccessed within the sequence. Please see the\n:ref:`sec_c_api_examples_tree_traversals` examples for recommended\nusage.\n\nOn initialisation, a tree is in the :ref:`null state` and\nwe must call one of the :ref:`seeking` methods to make\nthe state of the tree object correspond to a particular tree in the sequence.\nPlease see the :ref:`sec_c_api_examples_tree_iteration` examples for\nrecommended usage.\n\n@endrst\n */\ntypedef struct {\n /**\n * @brief The parent tree sequence.\n */\n const tsk_treeseq_t *tree_sequence;\n /**\n @brief The ID of the \"virtual root\" whose children are the roots of the\n tree.\n */\n tsk_id_t virtual_root;\n /**\n @brief The parent of node u is parent[u]. Equal to ``TSK_NULL`` if node u is\n a root or is not a node in the current tree.\n */\n tsk_id_t *parent;\n /**\n @brief The leftmost child of node u is left_child[u]. Equal to ``TSK_NULL``\n if node u is a leaf or is not a node in the current tree.\n */\n tsk_id_t *left_child;\n /**\n @brief The rightmost child of node u is right_child[u]. Equal to ``TSK_NULL``\n if node u is a leaf or is not a node in the current tree.\n */\n tsk_id_t *right_child;\n /**\n @brief The sibling to the left of node u is left_sib[u]. Equal to\n ``TSK_NULL`` if node u has no siblings to its left.\n */\n tsk_id_t *left_sib;\n /**\n @brief The sibling to the right of node u is right_sib[u]. Equal to\n ``TSK_NULL`` if node u has no siblings to its right.\n */\n tsk_id_t *right_sib;\n /**\n @brief The number of children of node u is num_children[u].\n */\n tsk_id_t *num_children;\n /**\n @brief Array of edge ids where ``edge[u]`` is the edge that encodes the\n relationship between the child node ``u`` and its parent. Equal to\n ``TSK_NULL`` if node ``u`` is a root, virtual root or is not a node in the\n current tree.\n */\n tsk_id_t *edge;\n /**\n @brief The total number of edges defining the topology of this tree.\n This is equal to the number of tree sequence edges that intersect with\n the tree's genomic interval.\n */\n tsk_size_t num_edges;\n /**\n @brief Left and right coordinates of the genomic interval that this\n tree covers. The left coordinate is inclusive and the right coordinate\n exclusive.\n\n @rst\n\n Example:\n\n .. code-block:: c\n\n tsk_tree_t tree;\n int ret;\n // initialise etc\n ret = tsk_tree_first(&tree);\n // Check for error\n assert(ret == TSK_TREE_OK);\n printf(\"Coordinates covered by first tree are left=%f, right=%f\\n\",\n tree.interval.left, tree.interval.right);\n\n @endrst\n\n */\n struct {\n double left;\n double right;\n } interval;\n /**\n @brief The index of this tree in the tree sequence.\n\n @rst\n This attribute provides the zero-based index of the tree represented by the\n current state of the struct within the parent tree sequence. For example,\n immediately after we call ``tsk_tree_first(&tree)``, ``tree.index`` will\n be zero, and after we call ``tsk_tree_last(&tree)``, ``tree.index`` will\n be the number of trees - 1 (see :c:func:`tsk_treeseq_get_num_trees`)\n When the tree is in the null state (immediately after initialisation,\n or after, e.g., calling :c:func:`tsk_tree_prev` on the first tree)\n the value of the ``index`` is -1.\n @endrst\n */\n tsk_id_t index;\n /* Attributes below are private and should not be used in client code. */\n tsk_size_t num_nodes;\n tsk_flags_t options;\n tsk_size_t root_threshold;\n const tsk_id_t *samples;\n /*\n These are involved in the optional sample tracking; num_samples counts\n all samples below a give node, and num_tracked_samples counts those\n from a specific subset. By default sample counts are tracked and roots\n maintained. If ``TSK_NO_SAMPLE_COUNTS`` is specified, then neither sample\n counts or roots are available.\n */\n tsk_size_t *num_samples;\n tsk_size_t *num_tracked_samples;\n /* These are for the optional sample list tracking. */\n tsk_id_t *left_sample;\n tsk_id_t *right_sample;\n tsk_id_t *next_sample;\n /* The sites on this tree */\n const tsk_site_t *sites;\n tsk_size_t sites_length;\n /* Counters needed for next() and prev() transformations. */\n int direction;\n tsk_id_t left_index;\n tsk_id_t right_index;\n tsk_tree_position_t tree_pos;\n} tsk_tree_t;\n\n/****************************************************************************/\n/* Tree sequence.*/\n/****************************************************************************/\n\n/**\n@defgroup TREESEQ_API_GROUP Tree sequence API\n@{\n*/\n\n/**\n@brief Initialises the tree sequence based on the specified table collection.\n\n@rst\nThis method will copy the supplied table collection unless :c:macro:`TSK_TAKE_OWNERSHIP`\nis specified. The table collection will be checked for integrity and index maps built.\n\nThis must be called before any operations are performed on the tree sequence.\nSee the :ref:`sec_c_api_overview_structure` for details on how objects\nare initialised and freed.\n\nIf specified, TSK_TAKE_OWNERSHIP takes immediate ownership of the tables, regardless\nof error conditions.\n\n**Options**\n\n- :c:macro:`TSK_TS_INIT_BUILD_INDEXES`\n- :c:macro:`TSK_TAKE_OWNERSHIP` (applies to the table collection).\n@endrst\n\n@param self A pointer to an uninitialised tsk_table_collection_t object.\n@param tables A pointer to a tsk_table_collection_t object.\n@param options Allocation time options. See above for details.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_init(\n tsk_treeseq_t *self, tsk_table_collection_t *tables, tsk_flags_t options);\n\n/**\n@brief Load a tree sequence from a file path.\n\n@rst\nLoads the data from the specified file into this tree sequence.\nThe tree sequence is also initialised.\nThe resources allocated must be freed using\n:c:func:`tsk_treeseq_free` even in error conditions.\n\nWorks similarly to :c:func:`tsk_table_collection_load` please see\nthat function's documentation for details and options.\n\n**Examples**\n\n.. code-block:: c\n\n int ret;\n tsk_treeseq_t ts;\n ret = tsk_treeseq_load(&ts, \"data.trees\", 0);\n if (ret != 0) {\n fprintf(stderr, \"Load error:%s\\n\", tsk_strerror(ret));\n exit(EXIT_FAILURE);\n }\n\n@endrst\n\n@param self A pointer to an uninitialised tsk_treeseq_t object\n@param filename A NULL terminated string containing the filename.\n@param options Bitwise options. See above for details.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_load(tsk_treeseq_t *self, const char *filename, tsk_flags_t options);\n\n/**\n@brief Load a tree sequence from a stream.\n\n@rst\nLoads a tree sequence from the specified file stream. The tree sequence\nis also initialised. The resources allocated must be freed using\n:c:func:`tsk_treeseq_free` even in error conditions.\n\nWorks similarly to :c:func:`tsk_table_collection_loadf` please\nsee that function's documentation for details and options.\n\n@endrst\n\n@param self A pointer to an uninitialised tsk_treeseq_t object.\n@param file A FILE stream opened in an appropriate mode for reading (e.g.\n \"r\", \"r+\" or \"w+\") positioned at the beginning of a tree sequence\n definition.\n@param options Bitwise options. See above for details.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_loadf(tsk_treeseq_t *self, FILE *file, tsk_flags_t options);\n\n/**\n@brief Write a tree sequence to file.\n\n@rst\nWrites the data from this tree sequence to the specified file.\n\nIf an error occurs the file path is deleted, ensuring that only complete\nand well formed files will be written.\n@endrst\n\n@param self A pointer to an initialised tsk_treeseq_t object.\n@param filename A NULL terminated string containing the filename.\n@param options Bitwise options. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_dump(\n const tsk_treeseq_t *self, const char *filename, tsk_flags_t options);\n\n/**\n@brief Write a tree sequence to a stream.\n\n@rst\nWrites the data from this tree sequence to the specified FILE stream.\nSemantics are identical to :c:func:`tsk_treeseq_dump`.\n\nPlease see the :ref:`sec_c_api_examples_file_streaming` section for an example\nof how to sequentially dump and load tree sequences from a stream.\n@endrst\n\n@param self A pointer to an initialised tsk_treeseq_t object.\n@param file A FILE stream opened in an appropriate mode for writing (e.g.\n \"w\", \"a\", \"r+\" or \"w+\").\n@param options Bitwise options. Currently unused; should be\n set to zero to ensure compatibility with later versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_dumpf(const tsk_treeseq_t *self, FILE *file, tsk_flags_t options);\n\n/**\n@brief Copies the state of the table collection underlying this tree sequence\ninto the specified destination table collection.\n\n@rst\nBy default the method initialises the specified destination table collection. If the\ndestination is already initialised, the :c:macro:`TSK_NO_INIT` option should\nbe supplied to avoid leaking memory.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@param tables A pointer to a tsk_table_collection_t object. If the TSK_NO_INIT\noption is specified, this must be an initialised table collection. If not, it must be an\nuninitialised table collection.\n@param options Bitwise option flags.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_copy_tables(\n const tsk_treeseq_t *self, tsk_table_collection_t *tables, tsk_flags_t options);\n\n/**\n@brief Free the internal memory for the specified tree sequence.\n\n@param self A pointer to an initialised tsk_treeseq_t object.\n@return Always returns 0.\n*/\nint tsk_treeseq_free(tsk_treeseq_t *self);\n\n/**\n@brief Print out the state of this tree sequence to the specified stream.\n\nThis method is intended for debugging purposes and should not be used\nin production code. The format of the output should **not** be depended\non and may change arbitrarily between versions.\n\n@param self A pointer to a tsk_treeseq_t object.\n@param out The stream to write the summary to.\n*/\nvoid tsk_treeseq_print_state(const tsk_treeseq_t *self, FILE *out);\n\n/**\n@brief Get the number of nodes\n\n@rst\nReturns the number of nodes in this tree sequence.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the number of nodes.\n*/\ntsk_size_t tsk_treeseq_get_num_nodes(const tsk_treeseq_t *self);\n\n/**\n@brief Get the number of edges\n\n@rst\nReturns the number of edges in this tree sequence.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the number of edges.\n*/\n\ntsk_size_t tsk_treeseq_get_num_edges(const tsk_treeseq_t *self);\n\n/**\n@brief Get the number of migrations\n\n@rst\nReturns the number of migrations in this tree sequence.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the number of migrations.\n*/\ntsk_size_t tsk_treeseq_get_num_migrations(const tsk_treeseq_t *self);\n\n/**\n@brief Get the number of sites\n\n@rst\nReturns the number of sites in this tree sequence.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the number of sites.\n*/\ntsk_size_t tsk_treeseq_get_num_sites(const tsk_treeseq_t *self);\n\n/**\n@brief Get the number of mutations\n\n@rst\nReturns the number of mutations in this tree sequence.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the number of mutations.\n*/\ntsk_size_t tsk_treeseq_get_num_mutations(const tsk_treeseq_t *self);\n\n/**\n@brief Get the number of provenances\n\n@rst\nReturns the number of provenances in this tree sequence.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the number of provenances.\n*/\ntsk_size_t tsk_treeseq_get_num_provenances(const tsk_treeseq_t *self);\n\n/**\n@brief Get the number of populations\n\n@rst\nReturns the number of populations in this tree sequence.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the number of populations.\n*/\ntsk_size_t tsk_treeseq_get_num_populations(const tsk_treeseq_t *self);\n\n/**\n@brief Get the number of individuals\n\n@rst\nReturns the number of individuals in this tree sequence.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the number of individuals.\n*/\ntsk_size_t tsk_treeseq_get_num_individuals(const tsk_treeseq_t *self);\n\n/**\n@brief Return the number of trees in this tree sequence.\n\n@rst\nThis is a constant time operation.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return The number of trees in the tree sequence.\n*/\ntsk_size_t tsk_treeseq_get_num_trees(const tsk_treeseq_t *self);\n\n/**\n@brief Get the number of samples\n\n@rst\nReturns the number of nodes marked as samples in this tree sequence.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the number of samples.\n*/\ntsk_size_t tsk_treeseq_get_num_samples(const tsk_treeseq_t *self);\n\n/**\n@brief Get the top-level tree sequence metadata.\n\n@rst\nReturns a pointer to the metadata string, which is owned by the tree sequence and\nnot null-terminated.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns a pointer to the metadata.\n*/\nconst char *tsk_treeseq_get_metadata(const tsk_treeseq_t *self);\n\n/**\n@brief Get the length of top-level tree sequence metadata\n\n@rst\nReturns the length of the metadata string.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the length of the metadata.\n*/\ntsk_size_t tsk_treeseq_get_metadata_length(const tsk_treeseq_t *self);\n\n/**\n@brief Get the top-level tree sequence metadata schema.\n\n@rst\nReturns a pointer to the metadata schema string, which is owned by the tree sequence and\nnot null-terminated.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns a pointer to the metadata schema.\n*/\nconst char *tsk_treeseq_get_metadata_schema(const tsk_treeseq_t *self);\n\n/**\n@brief Get the length of the top-level tree sequence metadata schema.\n\n@rst\nReturns the length of the metadata schema string.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the length of the metadata schema.\n*/\ntsk_size_t tsk_treeseq_get_metadata_schema_length(const tsk_treeseq_t *self);\n\n/**\n@brief Get the time units string\n\n@rst\nReturns a pointer to the time units string, which is owned by the tree sequence and\nnot null-terminated.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns a pointer to the time units.\n*/\nconst char *tsk_treeseq_get_time_units(const tsk_treeseq_t *self);\n\n/**\n@brief Get the length of time units string\n@rst\nReturns the length of the time units string.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the length of the time units.\n*/\ntsk_size_t tsk_treeseq_get_time_units_length(const tsk_treeseq_t *self);\n\n/**\n@brief Get the file uuid\n\n@rst\nReturns a pointer to the null-terminated file uuid string, which is owned by the tree\nsequence.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns a pointer to the null-terminated file uuid.\n*/\nconst char *tsk_treeseq_get_file_uuid(const tsk_treeseq_t *self);\n\n/**\n@brief Get the sequence length\n\n@rst\nReturns the sequence length of this tree sequence\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the sequence length.\n*/\ndouble tsk_treeseq_get_sequence_length(const tsk_treeseq_t *self);\n\n/**\n@brief Get the breakpoints\n\n@rst\nReturns an array of breakpoint locations, the array is owned by the tree sequence.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the pointer to the breakpoint array.\n*/\nconst double *tsk_treeseq_get_breakpoints(const tsk_treeseq_t *self);\n\n/**\n@brief Get the samples\n\n@rst\nReturns an array of ids of sample nodes in this tree sequence.\nI.e. nodes that have the :c:macro:`TSK_NODE_IS_SAMPLE` flag set.\nThe array is owned by the tree sequence and should not be modified or free'd.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the pointer to the sample node id array.\n*/\nconst tsk_id_t *tsk_treeseq_get_samples(const tsk_treeseq_t *self);\n\n/**\n@brief Get the map of node id to sample index\n\n@rst\nReturns the location of each node in the list of samples or\n:c:macro:`TSK_NULL` for nodes that are not samples.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the pointer to the array of sample indexes.\n*/\nconst tsk_id_t *tsk_treeseq_get_sample_index_map(const tsk_treeseq_t *self);\n\n/**\n@brief Check if a node is a sample\n\n@rst\nReturns the sample status of a given node id.\n@endrst\n@param self A pointer to a tsk_treeseq_t object.\n@param u The id of the node to be checked.\n@return Returns true if the node is a sample.\n*/\nbool tsk_treeseq_is_sample(const tsk_treeseq_t *self, tsk_id_t u);\n\n/**\n@brief Get the discrete genome status\n\n@rst\nIf all the genomic locations in the tree sequence are discrete integer values\nthen this flag will be true.\n@endrst\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns true if all genomic locations are discrete.\n*/\nbool tsk_treeseq_get_discrete_genome(const tsk_treeseq_t *self);\n\n/**\n@brief Get the discrete time status\n\n@rst\nIf all times in the tree sequence are discrete integer values\nthen this flag will be true\n@endrst\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns true if all times are discrete.\n*/\nbool tsk_treeseq_get_discrete_time(const tsk_treeseq_t *self);\n\n/**\n@brief Get the min time in node table and mutation table\n\n@rst\nThe times stored in both the node and mutation tables are considered.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the min time of all nodes and mutations.\n*/\ndouble tsk_treeseq_get_min_time(const tsk_treeseq_t *self);\n\n/**\n@brief Get the max time in node table and mutation table\n\n@rst\nThe times stored in both the node and mutation tables are considered.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@return Returns the max time of all nodes and mutations.\n*/\ndouble tsk_treeseq_get_max_time(const tsk_treeseq_t *self);\n\n/**\n@brief Get a node by its index\n\n@rst\nCopies a node from this tree sequence to the specified destination.\n@endrst\n@param self A pointer to a tsk_treeseq_t object.\n@param index The node index to copy\n@param node A pointer to a tsk_node_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_get_node(const tsk_treeseq_t *self, tsk_id_t index, tsk_node_t *node);\n\n/**\n@brief Get a edge by its index\n\n@rst\nCopies a edge from this tree sequence to the specified destination.\n@endrst\n@param self A pointer to a tsk_treeseq_t object.\n@param index The edge index to copy\n@param edge A pointer to a tsk_edge_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_get_edge(const tsk_treeseq_t *self, tsk_id_t index, tsk_edge_t *edge);\n\n/**\n@brief Get a edge by its index\n\n@rst\nCopies a migration from this tree sequence to the specified destination.\n@endrst\n@param self A pointer to a tsk_treeseq_t object.\n@param index The migration index to copy\n@param migration A pointer to a tsk_migration_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_get_migration(\n const tsk_treeseq_t *self, tsk_id_t index, tsk_migration_t *migration);\n\n/**\n@brief Get a site by its index\n\n@rst\nCopies a site from this tree sequence to the specified destination.\n@endrst\n@param self A pointer to a tsk_treeseq_t object.\n@param index The site index to copy\n@param site A pointer to a tsk_site_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_get_site(const tsk_treeseq_t *self, tsk_id_t index, tsk_site_t *site);\n\n/**\n@brief Get a mutation by its index\n\n@rst\nCopies a mutation from this tree sequence to the specified destination.\n@endrst\n@param self A pointer to a tsk_treeseq_t object.\n@param index The mutation index to copy\n@param mutation A pointer to a tsk_mutation_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_get_mutation(\n const tsk_treeseq_t *self, tsk_id_t index, tsk_mutation_t *mutation);\n\n/**\n@brief Get a provenance by its index\n\n@rst\nCopies a provenance from this tree sequence to the specified destination.\n@endrst\n@param self A pointer to a tsk_treeseq_t object.\n@param index The provenance index to copy\n@param provenance A pointer to a tsk_provenance_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_get_provenance(\n const tsk_treeseq_t *self, tsk_id_t index, tsk_provenance_t *provenance);\n\n/**\n@brief Get a population by its index\n\n@rst\nCopies a population from this tree sequence to the specified destination.\n@endrst\n@param self A pointer to a tsk_treeseq_t object.\n@param index The population index to copy\n@param population A pointer to a tsk_population_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_get_population(\n const tsk_treeseq_t *self, tsk_id_t index, tsk_population_t *population);\n\n/**\n@brief Get a individual by its index\n\n@rst\nCopies a individual from this tree sequence to the specified destination.\n@endrst\n@param self A pointer to a tsk_treeseq_t object.\n@param index The individual index to copy\n@param individual A pointer to a tsk_individual_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_get_individual(\n const tsk_treeseq_t *self, tsk_id_t index, tsk_individual_t *individual);\n\n/**\n@brief Create a simplified instance of this tree sequence\n\n@rst\nCopies this tree sequence to the specified destination and performs simplification.\nThe destination tree sequence should be uninitialised.\nSimplification transforms the tables to remove redundancy and canonicalise\ntree sequence data. See the :ref:`simplification ` tutorial for\nmore details.\n\nFor full details and flags see :c:func:`tsk_table_collection_simplify` which performs\nthe same operation in place.\n\n@endrst\n@param self A pointer to a uninitialised tsk_treeseq_t object.\n@param samples Either NULL or an array of num_samples distinct and valid node IDs.\n If non-null the nodes in this array will be marked as samples in the output.\n If NULL, the num_samples parameter is ignored and the samples in the output\n will be the same as the samples in the input. This is equivalent to populating\n the samples array with all of the sample nodes in the input in increasing\n order of ID.\n@param num_samples The number of node IDs in the input samples array. Ignored\n if the samples array is NULL.\n@param options Simplify options; see above for the available bitwise flags.\n For the default behaviour, a value of 0 should be provided.\n@param output A pointer to an uninitialised tsk_treeseq_t object.\n@param node_map If not NULL, this array will be filled to define the mapping\n between nodes IDs in the table collection before and after simplification.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_simplify(const tsk_treeseq_t *self, const tsk_id_t *samples,\n tsk_size_t num_samples, tsk_flags_t options, tsk_treeseq_t *output,\n tsk_id_t *node_map);\n\n/**\n@brief Extends haplotypes\n\nReturns a new tree sequence in which the span covered by ancestral nodes\nis \"extended\" to regions of the genome according to the following rule:\nIf an ancestral segment corresponding to node `n` has ancestor `p` and\ndescendant `c` on some portion of the genome, and on an adjacent segment of\ngenome `p` is still an ancestor of `c`, then `n` is inserted into the\npath from `p` to `c`. For instance, if `p` is the parent of `n` and `n`\nis the parent of `c`, then the span of the edges from `p` to `n` and\n`n` to `c` are extended, and the span of the edge from `p` to `c` is\nreduced. However, any edges whose child node is a sample are not\nmodified. See Fritze et al. (2025):\nhttps://doi.org/10.1093/genetics/iyaf198 for more details.\n\nThe method works by iterating over the genome to look for edges that can\nbe extended in this way; the maximum number of such iterations is\ncontrolled by ``max_iter``.\n\nThe `node` of certain mutations may also be remapped; to do this\nunambiguously we need to know mutation times. If mutations times are unknown,\nuse `tsk_table_collection_compute_mutation_times` first.\n\nThe method will not affect any tables except the edge table, or the node\ncolumn in the mutation table.\n\n@rst\n\n**Options**: None currently defined.\n@endrst\n\n@param self A pointer to a tsk_treeseq_t object.\n@param max_iter The maximum number of iterations over the tree sequence.\n@param options Bitwise option flags. (UNUSED)\n@param output A pointer to an uninitialised tsk_treeseq_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_extend_haplotypes(\n const tsk_treeseq_t *self, int max_iter, tsk_flags_t options, tsk_treeseq_t *output);\n\n/** @} */\n\nint tsk_treeseq_split_edges(const tsk_treeseq_t *self, double time, tsk_flags_t flags,\n tsk_id_t population, const char *metadata, tsk_size_t metadata_length,\n tsk_flags_t options, tsk_treeseq_t *output);\n\nbool tsk_treeseq_has_reference_sequence(const tsk_treeseq_t *self);\n\n/**\n@brief Decode full-length alignments for specified nodes over an interval.\n\n@rst\nFills a caller-provided buffer with per-node sequence alignments for the interval\n``[left, right)``. Each row is exactly ``L = right - left`` bytes with no trailing\nterminator, and rows are tightly packed in row-major order in the output buffer.\n\nThe output at non-site positions comes from the provided ``ref_seq`` slice\n(``ref_seq[left:right]``); per-site alleles are overlaid onto this for each node.\n\nIf the :c:macro:`TSK_ISOLATED_NOT_MISSING` option is\nnot set, nodes that are isolated (no parent and no children) within a tree\ninterval in ``[left, right)`` are rendered as the ``missing_data_character`` for\nthat interval. At site positions, decoded genotypes override any previous value;\nif a genotype is missing (``TSK_MISSING_DATA``), the ``missing_data_character`` is\noverlaid onto the reference base.\n\nRequirements and validation:\n\n- The tree sequence must have a discrete genome.\n- ``left`` and ``right`` must be integers with ``0 <= left < right <= sequence_length``.\n- ``ref_seq`` must be non-NULL and ``ref_seq_length == sequence_length``.\n- Each allele at a site must be exactly one byte; alleles equal to\n ``missing_data_character`` are not permitted.\n\n@endrst\n\n@param self A pointer to a :c:type:`tsk_treeseq_t` object.\n@param ref_seq Pointer to a reference sequence buffer of length ``ref_seq_length``.\n@param ref_seq_length The total length of ``ref_seq``; must equal the tree sequence\nlength.\n@param nodes Array of node IDs to decode (may include non-samples).\n@param num_nodes The number of nodes in ``nodes`` and rows in the output.\n@param left The inclusive-left genomic coordinate of the output interval.\n@param right The exclusive-right genomic coordinate of the output interval.\n@param missing_data_character The byte to use for missing data.\n@param alignments_out Output buffer of size at least ``num_nodes * (right - left)``.\n@param options Bitwise option flags; supports :c:macro:`TSK_ISOLATED_NOT_MISSING`.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_treeseq_decode_alignments(const tsk_treeseq_t *self, const char *ref_seq,\n tsk_size_t ref_seq_length, const tsk_id_t *nodes, tsk_size_t num_nodes, double left,\n double right, char missing_data_character, char *alignments_out,\n tsk_flags_t options);\n\nint tsk_treeseq_get_individuals_population(const tsk_treeseq_t *self, tsk_id_t *output);\nint tsk_treeseq_get_individuals_time(const tsk_treeseq_t *self, double *output);\n\nint tsk_treeseq_kc_distance(const tsk_treeseq_t *self, const tsk_treeseq_t *other,\n double lambda_, double *result);\n\nint tsk_treeseq_genealogical_nearest_neighbours(const tsk_treeseq_t *self,\n const tsk_id_t *focal, tsk_size_t num_focal, const tsk_id_t *const *reference_sets,\n const tsk_size_t *reference_set_size, tsk_size_t num_reference_sets,\n tsk_flags_t options, double *ret_array);\nint tsk_treeseq_mean_descendants(const tsk_treeseq_t *self,\n const tsk_id_t *const *reference_sets, const tsk_size_t *reference_set_size,\n tsk_size_t num_reference_sets, tsk_flags_t options, double *ret_array);\n\ntypedef int general_stat_func_t(tsk_size_t state_dim, const double *state,\n tsk_size_t result_dim, double *result, void *params);\n\nint tsk_treeseq_general_stat(const tsk_treeseq_t *self, tsk_size_t K, const double *W,\n tsk_size_t M, general_stat_func_t *f, void *f_params, tsk_size_t num_windows,\n const double *windows, tsk_flags_t options, double *result);\n\ntypedef int norm_func_t(tsk_size_t result_dim, const double *hap_weights, tsk_size_t n_a,\n tsk_size_t n_b, double *result, void *params);\n\nint tsk_treeseq_two_locus_count_stat(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t result_dim, const tsk_id_t *set_indexes,\n general_stat_func_t *f, norm_func_t *norm_f, tsk_size_t out_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t out_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result);\n\n/* One way weighted stats */\n\ntypedef int one_way_weighted_method(const tsk_treeseq_t *self, tsk_size_t num_weights,\n const double *weights, tsk_size_t num_windows, const double *windows,\n tsk_flags_t options, double *result);\n\nint tsk_treeseq_trait_covariance(const tsk_treeseq_t *self, tsk_size_t num_weights,\n const double *weights, tsk_size_t num_windows, const double *windows,\n tsk_flags_t options, double *result);\nint tsk_treeseq_trait_correlation(const tsk_treeseq_t *self, tsk_size_t num_weights,\n const double *weights, tsk_size_t num_windows, const double *windows,\n tsk_flags_t options, double *result);\n\n/* One way weighted stats with covariates */\n\ntypedef int one_way_covariates_method(const tsk_treeseq_t *self, tsk_size_t num_weights,\n const double *weights, tsk_size_t num_covariates, const double *covariates,\n tsk_size_t num_windows, const double *windows, tsk_flags_t options, double *result);\n\nint tsk_treeseq_trait_linear_model(const tsk_treeseq_t *self, tsk_size_t num_weights,\n const double *weights, tsk_size_t num_covariates, const double *covariates,\n tsk_size_t num_windows, const double *windows, tsk_flags_t options, double *result);\n\n/* Two way weighted stats with covariates */\n\ntypedef int two_way_weighted_method(const tsk_treeseq_t *self, tsk_size_t num_weights,\n const double *weights, tsk_size_t num_index_tuples, const tsk_id_t *index_tuples,\n tsk_size_t num_windows, const double *windows, double *result, tsk_flags_t options);\n\nint tsk_treeseq_genetic_relatedness_weighted(const tsk_treeseq_t *self,\n tsk_size_t num_weights, const double *weights, tsk_size_t num_index_tuples,\n const tsk_id_t *index_tuples, tsk_size_t num_windows, const double *windows,\n double *result, tsk_flags_t options);\n\n/* One way weighted stats with vector output */\n\ntypedef int weighted_vector_method(const tsk_treeseq_t *self, tsk_size_t num_weights,\n const double *weights, tsk_size_t num_windows, const double *windows,\n tsk_size_t num_focal_nodes, const tsk_id_t *focal_nodes, double *result,\n tsk_flags_t options);\n\nint tsk_treeseq_genetic_relatedness_vector(const tsk_treeseq_t *self,\n tsk_size_t num_weights, const double *weights, tsk_size_t num_windows,\n const double *windows, tsk_size_t num_focal_nodes, const tsk_id_t *focal_nodes,\n double *result, tsk_flags_t options);\n\n/* One way sample set stats */\n\ntypedef int one_way_sample_stat_method(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_windows, const double *windows,\n tsk_flags_t options, double *result);\n\nint tsk_treeseq_diversity(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_windows, const double *windows, tsk_flags_t options, double *result);\nint tsk_treeseq_segregating_sites(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_windows, const double *windows, tsk_flags_t options, double *result);\nint tsk_treeseq_Y1(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_windows, const double *windows, tsk_flags_t options, double *result);\nint tsk_treeseq_allele_frequency_spectrum(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_windows, const double *windows,\n tsk_size_t num_time_windows, const double *time_windows, tsk_flags_t options,\n double *result);\n\ntypedef int general_sample_stat_method(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_indexes, const tsk_id_t *indexes,\n tsk_size_t num_windows, const double *windows, tsk_flags_t options, double *result);\n\ntypedef int two_locus_count_stat_method(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_rows, const tsk_id_t *row_sites,\n const double *row_positions, tsk_size_t num_cols, const tsk_id_t *col_sites,\n const double *col_positions, tsk_flags_t options, double *result);\n\nint tsk_treeseq_D(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result);\nint tsk_treeseq_D2(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result);\nint tsk_treeseq_r2(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result);\nint tsk_treeseq_D_prime(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result);\nint tsk_treeseq_r(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result);\nint tsk_treeseq_Dz(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result);\nint tsk_treeseq_pi2(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result);\nint tsk_treeseq_D2_unbiased(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result);\nint tsk_treeseq_Dz_unbiased(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result);\nint tsk_treeseq_pi2_unbiased(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result);\n\ntypedef int k_way_two_locus_count_stat_method(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_index_tuples,\n const tsk_id_t *index_tuples, tsk_size_t num_rows, const tsk_id_t *row_sites,\n const double *row_positions, tsk_size_t num_cols, const tsk_id_t *col_sites,\n const double *col_positions, tsk_flags_t options, double *result);\n\n/* Two way sample set stats */\n\nint tsk_treeseq_divergence(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_windows,\n const double *windows, tsk_flags_t options, double *result);\nint tsk_treeseq_Y2(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_windows,\n const double *windows, tsk_flags_t options, double *result);\nint tsk_treeseq_f2(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_windows,\n const double *windows, tsk_flags_t options, double *result);\nint tsk_treeseq_genetic_relatedness(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_index_tuples,\n const tsk_id_t *index_tuples, tsk_size_t num_windows, const double *windows,\n tsk_flags_t options, double *result);\nint tsk_treeseq_D2_ij(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result);\nint tsk_treeseq_D2_ij_unbiased(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result);\nint tsk_treeseq_r2_ij(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_rows,\n const tsk_id_t *row_sites, const double *row_positions, tsk_size_t num_cols,\n const tsk_id_t *col_sites, const double *col_positions, tsk_flags_t options,\n double *result);\n\n/* Three way sample set stats */\nint tsk_treeseq_Y3(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_windows,\n const double *windows, tsk_flags_t options, double *result);\nint tsk_treeseq_f3(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_windows,\n const double *windows, tsk_flags_t options, double *result);\n\n/* Four way sample set stats */\nint tsk_treeseq_f4(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_index_tuples, const tsk_id_t *index_tuples, tsk_size_t num_windows,\n const double *windows, tsk_flags_t options, double *result);\n\nint tsk_treeseq_divergence_matrix(const tsk_treeseq_t *self, tsk_size_t num_sample_sets,\n const tsk_size_t *sample_set_sizes, const tsk_id_t *sample_sets,\n tsk_size_t num_windows, const double *windows, tsk_flags_t options, double *result);\n\n/* Coalescence rates */\ntypedef int pair_coalescence_stat_func_t(tsk_size_t input_dim, const double *atoms,\n const double *weights, tsk_size_t result_dim, double *result, void *params);\nint tsk_treeseq_pair_coalescence_stat(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_set_indexes, const tsk_id_t *set_indexes,\n tsk_size_t num_windows, const double *windows, tsk_size_t num_bins,\n const tsk_id_t *node_bin_map, pair_coalescence_stat_func_t *summary_func,\n tsk_size_t summary_func_dim, void *summary_func_args, tsk_flags_t options,\n double *result);\nint tsk_treeseq_pair_coalescence_counts(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_set_indexes, const tsk_id_t *set_indexes,\n tsk_size_t num_windows, const double *windows, tsk_size_t num_bins,\n const tsk_id_t *node_bin_map, tsk_flags_t options, double *result);\nint tsk_treeseq_pair_coalescence_quantiles(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_set_indexes, const tsk_id_t *set_indexes,\n tsk_size_t num_windows, const double *windows, tsk_size_t num_bins,\n const tsk_id_t *node_bin_map, tsk_size_t num_quantiles, double *quantiles,\n tsk_flags_t options, double *result);\nint tsk_treeseq_pair_coalescence_rates(const tsk_treeseq_t *self,\n tsk_size_t num_sample_sets, const tsk_size_t *sample_set_sizes,\n const tsk_id_t *sample_sets, tsk_size_t num_set_indexes, const tsk_id_t *set_indexes,\n tsk_size_t num_windows, const double *windows, tsk_size_t num_time_windows,\n const tsk_id_t *node_time_window, double *time_windows, tsk_flags_t options,\n double *result);\n\n/****************************************************************************/\n/* Tree */\n/****************************************************************************/\n\n/**\n@defgroup TREE_API_LIFECYCLE_GROUP Tree lifecycle\n@{\n*/\n\n/**\n@brief Initialises the tree by allocating internal memory and associating\n with the specified tree sequence.\n\n@rst\nThis must be called before any operations are performed on the tree.\n\nThe specified tree sequence object must be initialised, and must be\nvalid for the full lifetime of this tree.\n\nSee the :ref:`sec_c_api_overview_structure` for details on how objects\nare initialised and freed.\n\nThe ``options`` parameter is provided to support future expansions\nof the API. A number of undocumented internal features are controlled\nvia this parameter, and it **must** be set to 0 to ensure that operations\nwork as expected and for compatibility with future versions of tskit.\n@endrst\n\n@param self A pointer to an uninitialised tsk_tree_t object.\n@param tree_sequence A pointer to an initialised tsk_treeseq_t object.\n@param options Allocation time options. Must be 0, or behaviour is undefined.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_tree_init(\n tsk_tree_t *self, const tsk_treeseq_t *tree_sequence, tsk_flags_t options);\n\n/**\n@brief Free the internal memory for the specified tree.\n\n@param self A pointer to an initialised tsk_tree_t object.\n@return Always returns 0.\n*/\nint tsk_tree_free(tsk_tree_t *self);\n\n/**\n@brief Copies the state of this tree into the specified destination.\n\n@rst\nBy default (``options`` = 0) the method initialises the specified destination\ntree by calling :c:func:`tsk_tree_init`. If the destination is already\ninitialised, the :c:macro:`TSK_NO_INIT` option should be supplied to avoid\nleaking memory. If :c:macro:`TSK_NO_INIT` is supplied and the tree sequence associated\nwith the ``dest`` tree is not equal to the tree sequence associated\nwith ``self``, an error is raised.\n\nThe destination tree will keep a reference to the tree sequence object\nassociated with the source tree, and this tree sequence must be\nvalid for the full lifetime of the destination tree.\n\n**Options**\n\n- :c:macro:`TSK_NO_INIT`\n\nIf :c:macro:`TSK_NO_INIT` is not specified, options for :c:func:`tsk_tree_init`\ncan be provided and will be passed on.\n\n@endrst\n\n@param self A pointer to an initialised tsk_tree_t object.\n@param dest A pointer to a tsk_tree_t object. If the TSK_NO_INIT option\n is specified, this must be an initialised tree. If not, it must\n be an uninitialised tree.\n@param options Copy and allocation time options. See the notes above for details.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_tree_copy(const tsk_tree_t *self, tsk_tree_t *dest, tsk_flags_t options);\n\n/** @} */\n\n/**\n@defgroup TREE_API_SEEKING_GROUP Seeking along the sequence\n@{\n*/\n\n/** @brief Option to seek by skipping to the target tree, adding and removing as few\n edges as possible. If not specified, a linear time algorithm is used instead.\n\n @ingroup TREE_API_SEEKING_GROUP\n*/\n#define TSK_SEEK_SKIP (1 << 0)\n\n/**\n@brief Seek to the first tree in the sequence.\n\n@rst\nSet the state of this tree to reflect the first tree in parent\ntree sequence.\n@endrst\n\n@param self A pointer to an initialised tsk_tree_t object.\n@return Return TSK_TREE_OK on success; or a negative value if an error occurs.\n*/\nint tsk_tree_first(tsk_tree_t *self);\n\n/**\n@brief Seek to the last tree in the sequence.\n\n@rst\nSet the state of this tree to reflect the last tree in parent\ntree sequence.\n@endrst\n\n@param self A pointer to an initialised tsk_tree_t object.\n@return Return TSK_TREE_OK on success; or a negative value if an error occurs.\n*/\nint tsk_tree_last(tsk_tree_t *self);\n\n/**\n@brief Seek to the next tree in the sequence.\n\n@rst\nSet the state of this tree to reflect the next tree in parent\ntree sequence. If the index of the current tree is ``j``,\nthen the after this operation the index will be ``j + 1``.\n\nCalling :c:func:`tsk_tree_next` a tree in the\n:ref:`null state` is equivalent to calling\n:c:func:`tsk_tree_first`.\n\nCalling :c:func:`tsk_tree_next` on the last tree in the\nsequence will transform it into the\n:ref:`null state` (equivalent to\ncalling :c:func:`tsk_tree_clear`).\n\nPlease see the :ref:`sec_c_api_examples_tree_iteration` examples for\nrecommended usage.\n@endrst\n\n@param self A pointer to an initialised tsk_tree_t object.\n@return Return TSK_TREE_OK on successfully transforming to a\nnon-null tree; 0 on successfully transforming into the null\ntree; or a negative value if an error occurs.\n*/\nint tsk_tree_next(tsk_tree_t *self);\n\n/**\n@brief Seek to the previous tree in the sequence.\n\n@rst\nSet the state of this tree to reflect the previous tree in parent\ntree sequence. If the index of the current tree is ``j``,\nthen the after this operation the index will be ``j - 1``.\n\nCalling :c:func:`tsk_tree_prev` a tree in the\n:ref:`null state` is equivalent to calling\n:c:func:`tsk_tree_last`.\n\nCalling :c:func:`tsk_tree_prev` on the first tree in the\nsequence will transform it into the\n:ref:`null state` (equivalent to\ncalling :c:func:`tsk_tree_clear`).\n\nPlease see the :ref:`sec_c_api_examples_tree_iteration` examples for\nrecommended usage.\n@endrst\n\n@param self A pointer to an initialised tsk_tree_t object.\n@return Return TSK_TREE_OK on successfully transforming to a\nnon-null tree; 0 on successfully transforming into the null\ntree; or a negative value if an error occurs.\n*/\nint tsk_tree_prev(tsk_tree_t *self);\n\n/**\n@brief Set the tree into the null state.\n\n@rst\nTransform this tree into the :ref:`null state`.\n@endrst\n\n@param self A pointer to an initialised tsk_tree_t object.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_tree_clear(tsk_tree_t *self);\n\n/**\n@brief Seek to a particular position on the genome.\n\n@rst\nSet the state of this tree to reflect the tree in parent\ntree sequence covering the specified ``position``. That is, on success\nwe will have ``tree.interval.left <= position`` and\nwe will have ``position < tree.interval.right``.\n\nSeeking to a position currently covered by the tree is\na constant time operation.\n\nSeeking to a position from a non-null tree uses a linear time\nalgorithm by default, unless the option :c:macro:`TSK_SEEK_SKIP`\nis specified. In this case, a faster algorithm is employed which skips\nto the target tree by removing and adding the minimal number of edges\npossible. However, this approach does not guarantee that edges are\ninserted and removed in time-sorted order.\n\n.. warning:: Using the :c:macro:`TSK_SEEK_SKIP` option\n may lead to edges not being inserted or removed in time-sorted order.\n\n@endrst\n\n@param self A pointer to an initialised tsk_tree_t object.\n@param position The position in genome coordinates\n@param options Seek options. See the notes above for details.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_tree_seek(tsk_tree_t *self, double position, tsk_flags_t options);\n\n/**\n@brief Seek to a specific tree in a tree sequence.\n\n@rst\nSet the state of this tree to reflect the tree in parent\ntree sequence whose index is ``0 <= tree < num_trees``.\n@endrst\n\n@param self A pointer to an initialised tsk_tree_t object.\n@param tree The target tree index.\n@param options Seek options. Currently unused. Set to 0 for compatibility\n with future versions of tskit.\n@return Return 0 on success or a negative value on failure.\n*/\nint tsk_tree_seek_index(tsk_tree_t *self, tsk_id_t tree, tsk_flags_t options);\n\n/** @} */\n\n/**\n@defgroup TREE_API_TREE_QUERY_GROUP Tree Queries\n@{\n*/\n\n/**\n@brief Returns the number of roots in this tree.\n\n@rst\nSee the :ref:`sec_data_model_tree_roots` section for more information\non how the roots of a tree are defined.\n@endrst\n\n@param self A pointer to an initialised tsk_tree_t object.\n@return Returns the number roots in this tree.\n*/\ntsk_size_t tsk_tree_get_num_roots(const tsk_tree_t *self);\n\n/**\n@brief Returns the leftmost root in this tree.\n\n@rst\nSee the :ref:`sec_data_model_tree_roots` section for more information\non how the roots of a tree are defined.\n\nThis function is equivalent to ``tree.left_child[tree.virtual_root]``.\n@endrst\n\n@param self A pointer to an initialised tsk_tree_t object.\n@return Returns the leftmost root in the tree.\n*/\ntsk_id_t tsk_tree_get_left_root(const tsk_tree_t *self);\n\n/**\n@brief Returns the rightmost root in this tree.\n\n@rst\nSee the :ref:`sec_data_model_tree_roots` section for more information\non how the roots of a tree are defined.\n\nThis function is equivalent to ``tree.right_child[tree.virtual_root]``.\n@endrst\n\n@param self A pointer to an initialised tsk_tree_t object.\n@return Returns the rightmost root in the tree.\n*/\ntsk_id_t tsk_tree_get_right_root(const tsk_tree_t *self);\n\n/**\n@brief Get the list of sites for this tree.\n\n@rst\nGets the list of :c:data:`tsk_site_t` objects in the parent tree sequence\nfor which the position lies within this tree's genomic interval.\n\nThe memory pointed to by the ``sites`` parameter is managed by the\n``tsk_tree_t`` object and must not be altered or freed by client code.\n\n.. code-block:: c\n\n static void\n print_sites(const tsk_tree_t *tree)\n {\n int ret;\n tsk_size_t j, num_sites;\n const tsk_site_t *sites;\n\n ret = tsk_tree_get_sites(tree, &sites, &num_sites);\n check_tsk_error(ret);\n for (j = 0; j < num_sites; j++) {\n printf(\"position = %f\\n\", sites[j].position);\n }\n }\n\nThis is a constant time operation.\n\n@endrst\n\n@param self A pointer to a tsk_tree_t object.\n@param sites The destination pointer for the list of sites.\n@param sites_length A pointer to a tsk_size_t value in which the number\n of sites is stored.\n@return 0 on success or a negative value on failure.\n*/\nint tsk_tree_get_sites(\n const tsk_tree_t *self, const tsk_site_t **sites, tsk_size_t *sites_length);\n\n/**\n@brief Return an upper bound on the number of nodes reachable\n from the roots of this tree.\n\n@rst\nThis function provides an upper bound on the number of nodes that\ncan be reached in tree traversals, and is intended to be used\nfor memory allocation purposes. If ``num_nodes`` is the number\nof nodes visited in a tree traversal from the\n:ref:`virtual root`\n(e.g., ``tsk_tree_preorder_from(tree, tree->virtual_root, nodes,\n&num_nodes)``), the bound ``N`` returned here is guaranteed to\nbe greater than or equal to ``num_nodes``.\n\n.. warning:: The precise value returned is not defined and should\n not be depended on, as it may change from version-to-version.\n\n@endrst\n\n@param self A pointer to a tsk_tree_t object.\n@return An upper bound on the number nodes reachable from the roots\n of this tree, or zero if this tree has not been initialised.\n*/\ntsk_size_t tsk_tree_get_size_bound(const tsk_tree_t *self);\n\n/**\n@brief Print out the state of this tree to the specified stream.\n\nThis method is intended for debugging purposes and should not be used\nin production code. The format of the output should **not** be depended\non and may change arbitrarily between versions.\n\n@param self A pointer to a tsk_tree_t object.\n@param out The stream to write the summary to.\n*/\nvoid tsk_tree_print_state(const tsk_tree_t *self, FILE *out);\n\n/** @} */\n\n/**\n@defgroup TREE_API_NODE_QUERY_GROUP Node Queries\n@{\n*/\n\n/**\n@brief Returns the parent of the specified node.\n\n@rst\nEquivalent to ``tree.parent[u]`` with bounds checking for the node u.\nPerformance sensitive code which can guarantee that the node u is\nvalid should use the direct array access in preference to this method.\n@endrst\n\n@param self A pointer to a tsk_tree_t object.\n@param u The tree node.\n@param parent A tsk_id_t pointer to store the returned parent node.\n@return 0 on success or a negative value on failure.\n*/\nint tsk_tree_get_parent(const tsk_tree_t *self, tsk_id_t u, tsk_id_t *parent);\n\n/**\n@brief Returns the time of the specified node.\n\n@rst\nEquivalent to ``tables->nodes.time[u]`` with bounds checking for the node u.\nPerformance sensitive code which can guarantee that the node u is\nvalid should use the direct array access in preference to this method,\nfor example:\n\n.. code-block:: c\n\n static void\n print_times(const tsk_tree_t *tree)\n {\n int ret;\n tsk_size_t num_nodes, j;\n const double *node_time = tree->tree_sequence->tables->nodes.time;\n tsk_id_t *nodes = malloc(tsk_tree_get_size_bound(tree) * sizeof(*nodes));\n\n if (nodes == NULL) {\n errx(EXIT_FAILURE, \"Out of memory\");\n }\n ret = tsk_tree_preorder(tree, nodes, &num_nodes);\n check_tsk_error(ret);\n for (j = 0; j < num_nodes; j++) {\n printf(\"time = %f\\n\", node_time[nodes[j]]);\n }\n free(nodes);\n }\n\n@endrst\n\n@param self A pointer to a tsk_tree_t object.\n@param u The tree node.\n@param ret_time A double pointer to store the returned node time.\n@return 0 on success or a negative value on failure.\n*/\nint tsk_tree_get_time(const tsk_tree_t *self, tsk_id_t u, double *ret_time);\n\n/**\n@brief Return number of nodes on the path from the specified node to root.\n\n@rst\nReturn the number of nodes on the path from u to root, not including u.\nThe depth of a root is therefore zero.\n\nAs a special case, the depth of the\n:ref:`virtual root ` is defined as -1.\n@endrst\n\n@param self A pointer to a tsk_tree_t object.\n@param u The tree node.\n@param ret_depth An int pointer to store the returned node depth.\n@return 0 on success or a negative value on failure.\n*/\nint tsk_tree_get_depth(const tsk_tree_t *self, tsk_id_t u, int *ret_depth);\n\n/**\n@brief Return the length of the branch ancestral to the specified node.\n\n@rst\nReturn the length of the branch ancestral to the specified node.\nBranch length is defined as difference between the time\nof a node and its parent. The branch length of a root is zero.\n@endrst\n\n@param self A pointer to a tsk_tree_t object.\n@param u The tree node.\n@param ret_branch_length A double pointer to store the returned branch length.\n@return 0 on success or a negative value on failure.\n*/\nint tsk_tree_get_branch_length(\n const tsk_tree_t *self, tsk_id_t u, double *ret_branch_length);\n\n/**\n@brief Computes the sum of the lengths of all branches reachable from\n the specified node, or from all roots if ``u=TSK_NULL``.\n\n@rst\nReturn the total branch length in a particular subtree or of the\nentire tree. If the specified node is :c:macro:`TSK_NULL` (or the\n:ref:`virtual root`)\nthe sum of the lengths of all branches reachable from roots\nis returned. Branch length is defined as difference between the time\nof a node and its parent. The branch length of a root is zero.\n\nNote that if the specified node is internal its branch length is\n*not* included, so that, e.g., the total branch length of a\nleaf node is zero.\n@endrst\n\n@param self A pointer to a tsk_tree_t object.\n@param u The root of the subtree of interest, or ``TSK_NULL`` to return the\n total branch length of the tree.\n@param ret_tbl A double pointer to store the returned total branch length.\n@return 0 on success or a negative value on failure.\n*/\nint tsk_tree_get_total_branch_length(\n const tsk_tree_t *self, tsk_id_t u, double *ret_tbl);\n\n/**\n@brief Counts the number of samples in the subtree rooted at a node.\n\n@rst\nReturns the number of samples descending from a particular node,\nincluding the node itself.\n\nThis is a constant time operation.\n@endrst\n\n@param self A pointer to a tsk_tree_t object.\n@param u The tree node.\n@param ret_num_samples A tsk_size_t pointer to store the returned\n number of samples.\n@return 0 on success or a negative value on failure.\n*/\nint tsk_tree_get_num_samples(\n const tsk_tree_t *self, tsk_id_t u, tsk_size_t *ret_num_samples);\n\n/**\n@brief Compute the most recent common ancestor of two nodes.\n\n@rst\nIf two nodes do not share a common ancestor in the current tree, the MRCA\nnode is :c:macro:`TSK_NULL`.\n@endrst\n\n@param self A pointer to a tsk_tree_t object.\n@param u A tree node.\n@param v A tree node.\n@param mrca A tsk_id_t pointer to store the returned most recent common ancestor node.\n@return 0 on success or a negative value on failure.\n*/\nint tsk_tree_get_mrca(const tsk_tree_t *self, tsk_id_t u, tsk_id_t v, tsk_id_t *mrca);\n\n/**\n@brief Returns true if u is a descendant of v.\n\n@rst\nReturns true if u and v are both valid nodes in the tree sequence\nand v lies on the path from u to root, and false otherwise.\n\nAny node is a descendant of itself.\n@endrst\n\n@param self A pointer to a tsk_tree_t object.\n@param u The descendant node.\n@param v The ancestral node.\n@return true if u is a descendant of v, and false otherwise.\n*/\nbool tsk_tree_is_descendant(const tsk_tree_t *self, tsk_id_t u, tsk_id_t v);\n\n/** @} */\n\n/**\n@defgroup TREE_API_TRAVERSAL_GROUP Traversal orders.\n@{\n*/\n\n/**\n@brief Fill an array with the nodes of this tree in preorder.\n\n@rst\nPopulate an array with the nodes in this tree in preorder. The array\nmust be pre-allocated and be sufficiently large to hold the array\nof nodes visited. The recommended approach is to use the\n:c:func:`tsk_tree_get_size_bound` function, as in the following example:\n\n.. code-block:: c\n\n static void\n print_preorder(tsk_tree_t *tree)\n {\n int ret;\n tsk_size_t num_nodes, j;\n tsk_id_t *nodes = malloc(tsk_tree_get_size_bound(tree) * sizeof(*nodes));\n\n if (nodes == NULL) {\n errx(EXIT_FAILURE, \"Out of memory\");\n }\n ret = tsk_tree_preorder(tree, nodes, &num_nodes);\n check_tsk_error(ret);\n for (j = 0; j < num_nodes; j++) {\n printf(\"Visit preorder %lld\\n\", (long long) nodes[j]);\n }\n free(nodes);\n }\n\n.. seealso::\n See the :ref:`sec_c_api_examples_tree_traversals` section for\n more examples.\n\n@endrst\n\n@param self A pointer to a tsk_tree_t object.\n@param nodes The tsk_id_t array to store nodes in. See notes above for\n details.\n@param num_nodes A pointer to a tsk_size_t value where we store the number\n of nodes in the traversal.\n@return 0 on success or a negative value on failure.\n*/\nint tsk_tree_preorder(const tsk_tree_t *self, tsk_id_t *nodes, tsk_size_t *num_nodes);\n\n/**\n@brief Fill an array with the nodes of this tree starting from a particular node.\n\n@rst\nAs for :c:func:`tsk_tree_preorder` but starting the traversal at a particular node\n(which will be the first node in the traversal list). The\n:ref:`virtual root` is a valid input for this function\nand will be treated like any other tree node. The value ``-1`` is a special case,\nin which we visit all nodes reachable from the roots, and equivalent to\ncalling :c:func:`tsk_tree_preorder`.\n\nSee :c:func:`tsk_tree_preorder` for details the requirements for the ``nodes``\narray.\n@endrst\n\n@param self A pointer to a tsk_tree_t object.\n@param root The root of the subtree to traverse, or -1 to visit all nodes.\n@param nodes The tsk_id_t array to store nodes in.\n@param num_nodes A pointer to a tsk_size_t value where we store the number\n of nodes in the traversal.\n@return 0 on success or a negative value on failure.\n*/\nint tsk_tree_preorder_from(\n const tsk_tree_t *self, tsk_id_t root, tsk_id_t *nodes, tsk_size_t *num_nodes);\n\n/**\n@brief Fill an array with the nodes of this tree in postorder.\n\n@rst\nPopulate an array with the nodes in this tree in postorder. The array\nmust be pre-allocated and be sufficiently large to hold the array\nof nodes visited. The recommended approach is to use the\n:c:func:`tsk_tree_get_size_bound` function, as in the following example:\n\n.. code-block:: c\n\n static void\n print_postorder(tsk_tree_t *tree)\n {\n int ret;\n tsk_size_t num_nodes, j;\n tsk_id_t *nodes = malloc(tsk_tree_get_size_bound(tree) * sizeof(*nodes));\n\n if (nodes == NULL) {\n errx(EXIT_FAILURE, \"Out of memory\");\n }\n ret = tsk_tree_postorder(tree, nodes, &num_nodes);\n check_tsk_error(ret);\n for (j = 0; j < num_nodes; j++) {\n printf(\"Visit postorder %lld\\n\", (long long) nodes[j]);\n }\n free(nodes);\n }\n\n.. seealso::\n See the :ref:`sec_c_api_examples_tree_traversals` section for\n more examples.\n\n@endrst\n\n@param self A pointer to a tsk_tree_t object.\n@param nodes The tsk_id_t array to store nodes in. See notes above for\n details.\n@param num_nodes A pointer to a tsk_size_t value where we store the number\n of nodes in the traversal.\n@return 0 on success or a negative value on failure.\n*/\nint tsk_tree_postorder(const tsk_tree_t *self, tsk_id_t *nodes, tsk_size_t *num_nodes);\n\n/**\n@brief Fill an array with the nodes of this tree starting from a particular node.\n\n@rst\nAs for :c:func:`tsk_tree_postorder` but starting the traversal at a particular node\n(which will be the last node in the traversal list). The\n:ref:`virtual root` is a valid input for this function\nand will be treated like any other tree node. The value ``-1`` is a special case,\nin which we visit all nodes reachable from the roots, and equivalent to\ncalling :c:func:`tsk_tree_postorder`.\n\nSee :c:func:`tsk_tree_postorder` for details the requirements for the ``nodes``\narray.\n@endrst\n\n@param self A pointer to a tsk_tree_t object.\n@param root The root of the subtree to traverse, or -1 to visit all nodes.\n@param nodes The tsk_id_t array to store nodes in. See\n :c:func:`tsk_tree_postorder` for more details.\n@param num_nodes A pointer to a tsk_size_t value where we store the number\n of nodes in the traversal.\n@return 0 on success or a negative value on failure.\n*/\nint tsk_tree_postorder_from(\n const tsk_tree_t *self, tsk_id_t root, tsk_id_t *nodes, tsk_size_t *num_nodes);\n\n/** @} */\n\n/* Undocumented for now */\n\nint tsk_tree_preorder_samples_from(\n const tsk_tree_t *self, tsk_id_t root, tsk_id_t *nodes, tsk_size_t *num_nodes);\n\nint tsk_tree_set_root_threshold(tsk_tree_t *self, tsk_size_t root_threshold);\ntsk_size_t tsk_tree_get_root_threshold(const tsk_tree_t *self);\n\nbool tsk_tree_has_sample_counts(const tsk_tree_t *self);\nbool tsk_tree_has_sample_lists(const tsk_tree_t *self);\n\nint tsk_tree_get_num_tracked_samples(\n const tsk_tree_t *self, tsk_id_t u, tsk_size_t *num_tracked_samples);\nint tsk_tree_set_tracked_samples(\n tsk_tree_t *self, tsk_size_t num_tracked_samples, const tsk_id_t *tracked_samples);\nint tsk_tree_track_descendant_samples(tsk_tree_t *self, tsk_id_t node);\n\ntypedef struct {\n tsk_id_t node;\n tsk_id_t parent;\n int32_t state;\n} tsk_state_transition_t;\n\nint tsk_tree_map_mutations(tsk_tree_t *self, int32_t *genotypes, double *cost_matrix,\n tsk_flags_t options, int32_t *ancestral_state, tsk_size_t *num_transitions,\n tsk_state_transition_t **transitions);\n\nint tsk_tree_kc_distance(\n const tsk_tree_t *self, const tsk_tree_t *other, double lambda, double *result);\n\n/* Don't document these balance metrics for now so it doesn't get in the way of\n * C API 1.0, but should be straightforward to document based on Python docs. */\nint tsk_tree_sackin_index(const tsk_tree_t *self, tsk_size_t *result);\nint tsk_tree_colless_index(const tsk_tree_t *self, tsk_size_t *result);\nint tsk_tree_b1_index(const tsk_tree_t *self, double *result);\n/* NOTE: if we document this as part of the C API we'll have to be more careful\n * about the error behaviour on bad log bases. At the moment we're just returning\n * the resulting value which can be nan, inf etc, but some surprising results\n * happen like a base 0 seems to return a finite value. */\nint tsk_tree_b2_index(const tsk_tree_t *self, double base, double *result);\n\nint tsk_tree_num_lineages(const tsk_tree_t *self, double t, tsk_size_t *result);\n\n/* Things to consider removing: */\n\n/* This is redundant, really */\nbool tsk_tree_is_sample(const tsk_tree_t *self, tsk_id_t u);\n\n/* Not terribly useful, since the definition is\n * return (self->tree_sequence == other->tree_sequence) && (self->index == other->index)\n * Remove?\n */\nbool tsk_tree_equals(const tsk_tree_t *self, const tsk_tree_t *other);\n\nint tsk_tree_position_init(\n tsk_tree_position_t *self, const tsk_treeseq_t *tree_sequence, tsk_flags_t options);\nint tsk_tree_position_free(tsk_tree_position_t *self);\nint tsk_tree_position_print_state(const tsk_tree_position_t *self, FILE *out);\nbool tsk_tree_position_next(tsk_tree_position_t *self);\nbool tsk_tree_position_prev(tsk_tree_position_t *self);\nint tsk_tree_position_seek_forward(tsk_tree_position_t *self, tsk_id_t index);\nint tsk_tree_position_seek_backward(tsk_tree_position_t *self, tsk_id_t index);\n\n#ifdef __cplusplus\n}\n#endif\n#endif\n"
},
{
"path": "c/tskit.h",
"content": "/*\n * MIT License\n *\n * Copyright (c) 2019-2024 Tskit Developers\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n/**\n * @file tskit.h\n * @brief Tskit API.\n */\n#ifndef __TSKIT_H__\n#define __TSKIT_H__\n\n#include \n#include \n#include \n#include